Merge branch 'main' into massive-endpoints

.gitignore

@@ -2,3 +2,5 @@
 /.idea
 /.vscode
 /.venv
+
+__pycache__

Makefile

@@ -8,8 +8,11 @@ run:
 	@ $(RUN_IN_ENV) uvicorn \
 		main:app \
 		--reload \
-		--reload-dir=service \
-		--lifespan=off
+		--reload-dir=app
+
+run-no-relad:
+	@ $(RUN_IN_ENV) uvicorn \
+		main:app
 
 shell:
 	@ $(RUN_IN_ENV) python manage.py shell

README.md

@@ -0,0 +1,4 @@
+
+OpenAPI interface: http://localhost:8000/schema/swagger
+Example project: https://github.com/litestar-org/litestar-pg-redis-docker/tree/main
+

app/controllers/_machine_template.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_XTEMPLATEX import (
+    Machine_XTEMPLATEX,
+    Machine_XTEMPLATEX_ReadDTO,
+    Machine_XTEMPLATEX_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_XTEMPLATEX(Controller):
+    dto = Machine_XTEMPLATEX_WriteDTO
+    return_dto = Machine_XTEMPLATEX_ReadDTO
+    path = "/company/{company_id:int}/machines-XTEMPLATEX"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-XTEMPLATEX"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_XTEMPLATEX]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_XTEMPLATEX]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/company.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import (
+    Company,
+    CompanyReadDTO,
+    CompanyWriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{company_id:int}"
+
+
+def provides_service(db_session: AsyncSession) -> Service:
+    """Constructs repository and service objects for the request."""
+    return Service(Repository(session=db_session))
+
+
+class CompanyController(Controller):
+    dto = CompanyWriteDTO
+    return_dto = CompanyReadDTO
+    path = "/companies"
+    dependencies = {
+        "service": Provide(provides_service, sync_to_thread=False),
+    }
+    tags = ["Companies"]
+
+    @get()
+    async def get_companies(
+        self, service: Service, search: Optional[str] = None
+    ) -> ObjectListResponse[Company]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_company(
+        self, service: Service, company_id: int
+    ) -> ObjectResponse[Company]:
+        content = await service.get(company_id)
+        return ObjectResponse(content=content)

app/controllers/fiscal_payment_mapping.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get, post
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.fiscal_payment_mapping import (
+    FiscalPaymentMapping,
+    FiscalPaymentMappingReadDTO,
+    FiscalPaymentMappingWriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.filters import ExactFilter
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{id:int}"
+
+
+def provides_service(db_session: AsyncSession) -> Service:
+    """Constructs repository and service objects for the request."""
+    return Service(Repository(session=db_session))
+
+
+class FiscalPaymentMappingController(Controller):
+    dto = FiscalPaymentMappingWriteDTO
+    return_dto = FiscalPaymentMappingReadDTO
+    path = "/fiscal-payment-mappings"
+    dependencies = {
+        "service": Provide(provides_service, sync_to_thread=False),
+    }
+    tags = ["FiscalPaymentMappings"]
+
+    @post()
+    async def create_fiscal_payment_mappings(
+        self, data: FiscalPaymentMapping, service: Service
+    ) -> FiscalPaymentMapping:
+        return await service.create(data)
+
+    @get()
+    async def get_fiscal_payment_mappings(
+        self, service: Service, payment_device_code: Optional[int] = None
+    ) -> ObjectListResponse[FiscalPaymentMapping]:
+        filters = []
+
+        if payment_device_code is not None:
+            filters.append(
+                ExactFilter[int](
+                    field_name="payment_device_code",
+                    value=payment_device_code,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_fiscal_payment_mapping(
+        self, service: Service, id: int
+    ) -> ObjectResponse[FiscalPaymentMapping]:
+        content = await service.get(id)
+        return ObjectResponse(content=content)

app/controllers/machine.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.machine import (
+    Machine,
+    MachineReadDTO,
+    MachineWriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController(Controller):
+    dto = MachineWriteDTO
+    return_dto = MachineReadDTO
+    path = "/company/{company_id:int}/machines"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00000.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00000 import (
+    Machine_00000,
+    Machine_00000_ReadDTO,
+    Machine_00000_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00000(Controller):
+    dto = Machine_00000_WriteDTO
+    return_dto = Machine_00000_ReadDTO
+    path = "/company/{company_id:int}/machines-00000"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00000"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00000]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00000]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00001.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00001 import (
+    Machine_00001,
+    Machine_00001_ReadDTO,
+    Machine_00001_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00001(Controller):
+    dto = Machine_00001_WriteDTO
+    return_dto = Machine_00001_ReadDTO
+    path = "/company/{company_id:int}/machines-00001"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00001"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00001]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00001]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00002.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00002 import (
+    Machine_00002,
+    Machine_00002_ReadDTO,
+    Machine_00002_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00002(Controller):
+    dto = Machine_00002_WriteDTO
+    return_dto = Machine_00002_ReadDTO
+    path = "/company/{company_id:int}/machines-00002"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00002"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00002]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00002]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00003.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00003 import (
+    Machine_00003,
+    Machine_00003_ReadDTO,
+    Machine_00003_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00003(Controller):
+    dto = Machine_00003_WriteDTO
+    return_dto = Machine_00003_ReadDTO
+    path = "/company/{company_id:int}/machines-00003"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00003"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00003]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00003]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00004.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00004 import (
+    Machine_00004,
+    Machine_00004_ReadDTO,
+    Machine_00004_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00004(Controller):
+    dto = Machine_00004_WriteDTO
+    return_dto = Machine_00004_ReadDTO
+    path = "/company/{company_id:int}/machines-00004"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00004"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00004]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00004]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00005.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00005 import (
+    Machine_00005,
+    Machine_00005_ReadDTO,
+    Machine_00005_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00005(Controller):
+    dto = Machine_00005_WriteDTO
+    return_dto = Machine_00005_ReadDTO
+    path = "/company/{company_id:int}/machines-00005"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00005"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00005]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00005]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00006.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00006 import (
+    Machine_00006,
+    Machine_00006_ReadDTO,
+    Machine_00006_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00006(Controller):
+    dto = Machine_00006_WriteDTO
+    return_dto = Machine_00006_ReadDTO
+    path = "/company/{company_id:int}/machines-00006"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00006"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00006]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00006]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00007.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00007 import (
+    Machine_00007,
+    Machine_00007_ReadDTO,
+    Machine_00007_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00007(Controller):
+    dto = Machine_00007_WriteDTO
+    return_dto = Machine_00007_ReadDTO
+    path = "/company/{company_id:int}/machines-00007"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00007"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00007]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00007]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00008.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00008 import (
+    Machine_00008,
+    Machine_00008_ReadDTO,
+    Machine_00008_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00008(Controller):
+    dto = Machine_00008_WriteDTO
+    return_dto = Machine_00008_ReadDTO
+    path = "/company/{company_id:int}/machines-00008"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00008"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00008]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00008]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00009.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00009 import (
+    Machine_00009,
+    Machine_00009_ReadDTO,
+    Machine_00009_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00009(Controller):
+    dto = Machine_00009_WriteDTO
+    return_dto = Machine_00009_ReadDTO
+    path = "/company/{company_id:int}/machines-00009"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00009"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00009]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00009]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00010.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00010 import (
+    Machine_00010,
+    Machine_00010_ReadDTO,
+    Machine_00010_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00010(Controller):
+    dto = Machine_00010_WriteDTO
+    return_dto = Machine_00010_ReadDTO
+    path = "/company/{company_id:int}/machines-00010"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00010"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00010]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00010]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00011.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00011 import (
+    Machine_00011,
+    Machine_00011_ReadDTO,
+    Machine_00011_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00011(Controller):
+    dto = Machine_00011_WriteDTO
+    return_dto = Machine_00011_ReadDTO
+    path = "/company/{company_id:int}/machines-00011"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00011"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00011]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00011]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00012.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00012 import (
+    Machine_00012,
+    Machine_00012_ReadDTO,
+    Machine_00012_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00012(Controller):
+    dto = Machine_00012_WriteDTO
+    return_dto = Machine_00012_ReadDTO
+    path = "/company/{company_id:int}/machines-00012"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00012"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00012]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00012]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00013.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00013 import (
+    Machine_00013,
+    Machine_00013_ReadDTO,
+    Machine_00013_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00013(Controller):
+    dto = Machine_00013_WriteDTO
+    return_dto = Machine_00013_ReadDTO
+    path = "/company/{company_id:int}/machines-00013"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00013"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00013]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00013]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00014.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00014 import (
+    Machine_00014,
+    Machine_00014_ReadDTO,
+    Machine_00014_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00014(Controller):
+    dto = Machine_00014_WriteDTO
+    return_dto = Machine_00014_ReadDTO
+    path = "/company/{company_id:int}/machines-00014"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00014"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00014]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00014]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00015.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00015 import (
+    Machine_00015,
+    Machine_00015_ReadDTO,
+    Machine_00015_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00015(Controller):
+    dto = Machine_00015_WriteDTO
+    return_dto = Machine_00015_ReadDTO
+    path = "/company/{company_id:int}/machines-00015"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00015"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00015]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00015]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00016.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00016 import (
+    Machine_00016,
+    Machine_00016_ReadDTO,
+    Machine_00016_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00016(Controller):
+    dto = Machine_00016_WriteDTO
+    return_dto = Machine_00016_ReadDTO
+    path = "/company/{company_id:int}/machines-00016"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00016"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00016]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00016]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00017.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00017 import (
+    Machine_00017,
+    Machine_00017_ReadDTO,
+    Machine_00017_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00017(Controller):
+    dto = Machine_00017_WriteDTO
+    return_dto = Machine_00017_ReadDTO
+    path = "/company/{company_id:int}/machines-00017"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00017"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00017]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00017]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00018.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00018 import (
+    Machine_00018,
+    Machine_00018_ReadDTO,
+    Machine_00018_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00018(Controller):
+    dto = Machine_00018_WriteDTO
+    return_dto = Machine_00018_ReadDTO
+    path = "/company/{company_id:int}/machines-00018"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00018"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00018]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00018]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00019.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00019 import (
+    Machine_00019,
+    Machine_00019_ReadDTO,
+    Machine_00019_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00019(Controller):
+    dto = Machine_00019_WriteDTO
+    return_dto = Machine_00019_ReadDTO
+    path = "/company/{company_id:int}/machines-00019"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00019"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00019]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00019]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00020.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00020 import (
+    Machine_00020,
+    Machine_00020_ReadDTO,
+    Machine_00020_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00020(Controller):
+    dto = Machine_00020_WriteDTO
+    return_dto = Machine_00020_ReadDTO
+    path = "/company/{company_id:int}/machines-00020"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00020"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00020]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00020]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00021.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00021 import (
+    Machine_00021,
+    Machine_00021_ReadDTO,
+    Machine_00021_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00021(Controller):
+    dto = Machine_00021_WriteDTO
+    return_dto = Machine_00021_ReadDTO
+    path = "/company/{company_id:int}/machines-00021"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00021"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00021]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00021]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00022.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00022 import (
+    Machine_00022,
+    Machine_00022_ReadDTO,
+    Machine_00022_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00022(Controller):
+    dto = Machine_00022_WriteDTO
+    return_dto = Machine_00022_ReadDTO
+    path = "/company/{company_id:int}/machines-00022"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00022"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00022]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00022]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00023.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00023 import (
+    Machine_00023,
+    Machine_00023_ReadDTO,
+    Machine_00023_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00023(Controller):
+    dto = Machine_00023_WriteDTO
+    return_dto = Machine_00023_ReadDTO
+    path = "/company/{company_id:int}/machines-00023"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00023"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00023]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00023]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00024.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00024 import (
+    Machine_00024,
+    Machine_00024_ReadDTO,
+    Machine_00024_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00024(Controller):
+    dto = Machine_00024_WriteDTO
+    return_dto = Machine_00024_ReadDTO
+    path = "/company/{company_id:int}/machines-00024"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00024"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00024]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00024]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00025.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00025 import (
+    Machine_00025,
+    Machine_00025_ReadDTO,
+    Machine_00025_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00025(Controller):
+    dto = Machine_00025_WriteDTO
+    return_dto = Machine_00025_ReadDTO
+    path = "/company/{company_id:int}/machines-00025"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00025"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00025]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00025]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00026.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00026 import (
+    Machine_00026,
+    Machine_00026_ReadDTO,
+    Machine_00026_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00026(Controller):
+    dto = Machine_00026_WriteDTO
+    return_dto = Machine_00026_ReadDTO
+    path = "/company/{company_id:int}/machines-00026"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00026"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00026]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00026]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00027.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00027 import (
+    Machine_00027,
+    Machine_00027_ReadDTO,
+    Machine_00027_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00027(Controller):
+    dto = Machine_00027_WriteDTO
+    return_dto = Machine_00027_ReadDTO
+    path = "/company/{company_id:int}/machines-00027"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00027"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00027]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00027]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00028.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00028 import (
+    Machine_00028,
+    Machine_00028_ReadDTO,
+    Machine_00028_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00028(Controller):
+    dto = Machine_00028_WriteDTO
+    return_dto = Machine_00028_ReadDTO
+    path = "/company/{company_id:int}/machines-00028"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00028"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00028]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00028]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00029.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00029 import (
+    Machine_00029,
+    Machine_00029_ReadDTO,
+    Machine_00029_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00029(Controller):
+    dto = Machine_00029_WriteDTO
+    return_dto = Machine_00029_ReadDTO
+    path = "/company/{company_id:int}/machines-00029"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00029"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00029]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00029]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00030.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00030 import (
+    Machine_00030,
+    Machine_00030_ReadDTO,
+    Machine_00030_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00030(Controller):
+    dto = Machine_00030_WriteDTO
+    return_dto = Machine_00030_ReadDTO
+    path = "/company/{company_id:int}/machines-00030"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00030"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00030]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00030]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00031.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00031 import (
+    Machine_00031,
+    Machine_00031_ReadDTO,
+    Machine_00031_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00031(Controller):
+    dto = Machine_00031_WriteDTO
+    return_dto = Machine_00031_ReadDTO
+    path = "/company/{company_id:int}/machines-00031"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00031"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00031]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00031]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00032.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00032 import (
+    Machine_00032,
+    Machine_00032_ReadDTO,
+    Machine_00032_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00032(Controller):
+    dto = Machine_00032_WriteDTO
+    return_dto = Machine_00032_ReadDTO
+    path = "/company/{company_id:int}/machines-00032"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00032"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00032]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00032]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00033.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00033 import (
+    Machine_00033,
+    Machine_00033_ReadDTO,
+    Machine_00033_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00033(Controller):
+    dto = Machine_00033_WriteDTO
+    return_dto = Machine_00033_ReadDTO
+    path = "/company/{company_id:int}/machines-00033"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00033"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00033]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00033]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00034.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00034 import (
+    Machine_00034,
+    Machine_00034_ReadDTO,
+    Machine_00034_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00034(Controller):
+    dto = Machine_00034_WriteDTO
+    return_dto = Machine_00034_ReadDTO
+    path = "/company/{company_id:int}/machines-00034"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00034"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00034]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00034]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00035.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00035 import (
+    Machine_00035,
+    Machine_00035_ReadDTO,
+    Machine_00035_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00035(Controller):
+    dto = Machine_00035_WriteDTO
+    return_dto = Machine_00035_ReadDTO
+    path = "/company/{company_id:int}/machines-00035"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00035"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00035]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00035]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00036.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00036 import (
+    Machine_00036,
+    Machine_00036_ReadDTO,
+    Machine_00036_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00036(Controller):
+    dto = Machine_00036_WriteDTO
+    return_dto = Machine_00036_ReadDTO
+    path = "/company/{company_id:int}/machines-00036"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00036"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00036]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00036]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00037.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00037 import (
+    Machine_00037,
+    Machine_00037_ReadDTO,
+    Machine_00037_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00037(Controller):
+    dto = Machine_00037_WriteDTO
+    return_dto = Machine_00037_ReadDTO
+    path = "/company/{company_id:int}/machines-00037"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00037"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00037]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00037]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00038.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00038 import (
+    Machine_00038,
+    Machine_00038_ReadDTO,
+    Machine_00038_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00038(Controller):
+    dto = Machine_00038_WriteDTO
+    return_dto = Machine_00038_ReadDTO
+    path = "/company/{company_id:int}/machines-00038"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00038"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00038]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00038]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00039.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00039 import (
+    Machine_00039,
+    Machine_00039_ReadDTO,
+    Machine_00039_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00039(Controller):
+    dto = Machine_00039_WriteDTO
+    return_dto = Machine_00039_ReadDTO
+    path = "/company/{company_id:int}/machines-00039"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00039"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00039]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00039]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00040.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00040 import (
+    Machine_00040,
+    Machine_00040_ReadDTO,
+    Machine_00040_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00040(Controller):
+    dto = Machine_00040_WriteDTO
+    return_dto = Machine_00040_ReadDTO
+    path = "/company/{company_id:int}/machines-00040"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00040"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00040]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00040]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00041.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00041 import (
+    Machine_00041,
+    Machine_00041_ReadDTO,
+    Machine_00041_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00041(Controller):
+    dto = Machine_00041_WriteDTO
+    return_dto = Machine_00041_ReadDTO
+    path = "/company/{company_id:int}/machines-00041"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00041"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00041]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00041]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00042.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00042 import (
+    Machine_00042,
+    Machine_00042_ReadDTO,
+    Machine_00042_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00042(Controller):
+    dto = Machine_00042_WriteDTO
+    return_dto = Machine_00042_ReadDTO
+    path = "/company/{company_id:int}/machines-00042"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00042"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00042]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00042]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00043.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00043 import (
+    Machine_00043,
+    Machine_00043_ReadDTO,
+    Machine_00043_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00043(Controller):
+    dto = Machine_00043_WriteDTO
+    return_dto = Machine_00043_ReadDTO
+    path = "/company/{company_id:int}/machines-00043"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00043"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00043]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00043]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00044.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00044 import (
+    Machine_00044,
+    Machine_00044_ReadDTO,
+    Machine_00044_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00044(Controller):
+    dto = Machine_00044_WriteDTO
+    return_dto = Machine_00044_ReadDTO
+    path = "/company/{company_id:int}/machines-00044"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00044"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00044]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00044]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00045.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00045 import (
+    Machine_00045,
+    Machine_00045_ReadDTO,
+    Machine_00045_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00045(Controller):
+    dto = Machine_00045_WriteDTO
+    return_dto = Machine_00045_ReadDTO
+    path = "/company/{company_id:int}/machines-00045"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00045"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00045]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00045]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00046.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00046 import (
+    Machine_00046,
+    Machine_00046_ReadDTO,
+    Machine_00046_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00046(Controller):
+    dto = Machine_00046_WriteDTO
+    return_dto = Machine_00046_ReadDTO
+    path = "/company/{company_id:int}/machines-00046"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00046"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00046]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00046]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00047.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00047 import (
+    Machine_00047,
+    Machine_00047_ReadDTO,
+    Machine_00047_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00047(Controller):
+    dto = Machine_00047_WriteDTO
+    return_dto = Machine_00047_ReadDTO
+    path = "/company/{company_id:int}/machines-00047"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00047"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00047]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00047]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00048.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00048 import (
+    Machine_00048,
+    Machine_00048_ReadDTO,
+    Machine_00048_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00048(Controller):
+    dto = Machine_00048_WriteDTO
+    return_dto = Machine_00048_ReadDTO
+    path = "/company/{company_id:int}/machines-00048"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00048"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00048]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00048]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00049.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00049 import (
+    Machine_00049,
+    Machine_00049_ReadDTO,
+    Machine_00049_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00049(Controller):
+    dto = Machine_00049_WriteDTO
+    return_dto = Machine_00049_ReadDTO
+    path = "/company/{company_id:int}/machines-00049"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00049"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00049]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00049]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00050.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00050 import (
+    Machine_00050,
+    Machine_00050_ReadDTO,
+    Machine_00050_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00050(Controller):
+    dto = Machine_00050_WriteDTO
+    return_dto = Machine_00050_ReadDTO
+    path = "/company/{company_id:int}/machines-00050"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00050"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00050]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00050]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00051.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00051 import (
+    Machine_00051,
+    Machine_00051_ReadDTO,
+    Machine_00051_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00051(Controller):
+    dto = Machine_00051_WriteDTO
+    return_dto = Machine_00051_ReadDTO
+    path = "/company/{company_id:int}/machines-00051"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00051"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00051]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00051]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00052.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00052 import (
+    Machine_00052,
+    Machine_00052_ReadDTO,
+    Machine_00052_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00052(Controller):
+    dto = Machine_00052_WriteDTO
+    return_dto = Machine_00052_ReadDTO
+    path = "/company/{company_id:int}/machines-00052"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00052"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00052]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00052]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00053.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00053 import (
+    Machine_00053,
+    Machine_00053_ReadDTO,
+    Machine_00053_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00053(Controller):
+    dto = Machine_00053_WriteDTO
+    return_dto = Machine_00053_ReadDTO
+    path = "/company/{company_id:int}/machines-00053"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00053"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00053]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00053]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00054.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00054 import (
+    Machine_00054,
+    Machine_00054_ReadDTO,
+    Machine_00054_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00054(Controller):
+    dto = Machine_00054_WriteDTO
+    return_dto = Machine_00054_ReadDTO
+    path = "/company/{company_id:int}/machines-00054"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00054"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00054]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00054]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00055.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00055 import (
+    Machine_00055,
+    Machine_00055_ReadDTO,
+    Machine_00055_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00055(Controller):
+    dto = Machine_00055_WriteDTO
+    return_dto = Machine_00055_ReadDTO
+    path = "/company/{company_id:int}/machines-00055"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00055"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00055]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00055]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00056.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00056 import (
+    Machine_00056,
+    Machine_00056_ReadDTO,
+    Machine_00056_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00056(Controller):
+    dto = Machine_00056_WriteDTO
+    return_dto = Machine_00056_ReadDTO
+    path = "/company/{company_id:int}/machines-00056"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00056"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00056]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00056]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00057.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00057 import (
+    Machine_00057,
+    Machine_00057_ReadDTO,
+    Machine_00057_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00057(Controller):
+    dto = Machine_00057_WriteDTO
+    return_dto = Machine_00057_ReadDTO
+    path = "/company/{company_id:int}/machines-00057"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00057"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00057]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00057]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00058.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00058 import (
+    Machine_00058,
+    Machine_00058_ReadDTO,
+    Machine_00058_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00058(Controller):
+    dto = Machine_00058_WriteDTO
+    return_dto = Machine_00058_ReadDTO
+    path = "/company/{company_id:int}/machines-00058"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00058"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00058]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00058]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00059.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00059 import (
+    Machine_00059,
+    Machine_00059_ReadDTO,
+    Machine_00059_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00059(Controller):
+    dto = Machine_00059_WriteDTO
+    return_dto = Machine_00059_ReadDTO
+    path = "/company/{company_id:int}/machines-00059"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00059"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00059]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00059]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00060.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00060 import (
+    Machine_00060,
+    Machine_00060_ReadDTO,
+    Machine_00060_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00060(Controller):
+    dto = Machine_00060_WriteDTO
+    return_dto = Machine_00060_ReadDTO
+    path = "/company/{company_id:int}/machines-00060"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00060"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00060]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00060]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00061.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00061 import (
+    Machine_00061,
+    Machine_00061_ReadDTO,
+    Machine_00061_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00061(Controller):
+    dto = Machine_00061_WriteDTO
+    return_dto = Machine_00061_ReadDTO
+    path = "/company/{company_id:int}/machines-00061"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00061"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00061]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00061]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00062.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00062 import (
+    Machine_00062,
+    Machine_00062_ReadDTO,
+    Machine_00062_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00062(Controller):
+    dto = Machine_00062_WriteDTO
+    return_dto = Machine_00062_ReadDTO
+    path = "/company/{company_id:int}/machines-00062"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00062"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00062]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00062]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00063.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00063 import (
+    Machine_00063,
+    Machine_00063_ReadDTO,
+    Machine_00063_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00063(Controller):
+    dto = Machine_00063_WriteDTO
+    return_dto = Machine_00063_ReadDTO
+    path = "/company/{company_id:int}/machines-00063"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00063"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00063]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00063]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00064.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00064 import (
+    Machine_00064,
+    Machine_00064_ReadDTO,
+    Machine_00064_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00064(Controller):
+    dto = Machine_00064_WriteDTO
+    return_dto = Machine_00064_ReadDTO
+    path = "/company/{company_id:int}/machines-00064"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00064"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00064]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00064]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00065.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00065 import (
+    Machine_00065,
+    Machine_00065_ReadDTO,
+    Machine_00065_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00065(Controller):
+    dto = Machine_00065_WriteDTO
+    return_dto = Machine_00065_ReadDTO
+    path = "/company/{company_id:int}/machines-00065"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00065"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00065]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00065]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00066.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00066 import (
+    Machine_00066,
+    Machine_00066_ReadDTO,
+    Machine_00066_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00066(Controller):
+    dto = Machine_00066_WriteDTO
+    return_dto = Machine_00066_ReadDTO
+    path = "/company/{company_id:int}/machines-00066"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00066"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00066]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00066]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00067.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00067 import (
+    Machine_00067,
+    Machine_00067_ReadDTO,
+    Machine_00067_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00067(Controller):
+    dto = Machine_00067_WriteDTO
+    return_dto = Machine_00067_ReadDTO
+    path = "/company/{company_id:int}/machines-00067"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00067"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00067]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00067]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00068.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00068 import (
+    Machine_00068,
+    Machine_00068_ReadDTO,
+    Machine_00068_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00068(Controller):
+    dto = Machine_00068_WriteDTO
+    return_dto = Machine_00068_ReadDTO
+    path = "/company/{company_id:int}/machines-00068"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00068"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00068]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00068]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00069.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00069 import (
+    Machine_00069,
+    Machine_00069_ReadDTO,
+    Machine_00069_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00069(Controller):
+    dto = Machine_00069_WriteDTO
+    return_dto = Machine_00069_ReadDTO
+    path = "/company/{company_id:int}/machines-00069"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00069"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00069]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00069]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00070.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00070 import (
+    Machine_00070,
+    Machine_00070_ReadDTO,
+    Machine_00070_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00070(Controller):
+    dto = Machine_00070_WriteDTO
+    return_dto = Machine_00070_ReadDTO
+    path = "/company/{company_id:int}/machines-00070"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00070"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00070]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00070]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00071.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00071 import (
+    Machine_00071,
+    Machine_00071_ReadDTO,
+    Machine_00071_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00071(Controller):
+    dto = Machine_00071_WriteDTO
+    return_dto = Machine_00071_ReadDTO
+    path = "/company/{company_id:int}/machines-00071"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00071"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00071]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00071]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00072.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00072 import (
+    Machine_00072,
+    Machine_00072_ReadDTO,
+    Machine_00072_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00072(Controller):
+    dto = Machine_00072_WriteDTO
+    return_dto = Machine_00072_ReadDTO
+    path = "/company/{company_id:int}/machines-00072"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00072"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00072]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00072]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00073.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00073 import (
+    Machine_00073,
+    Machine_00073_ReadDTO,
+    Machine_00073_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00073(Controller):
+    dto = Machine_00073_WriteDTO
+    return_dto = Machine_00073_ReadDTO
+    path = "/company/{company_id:int}/machines-00073"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00073"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00073]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00073]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00074.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00074 import (
+    Machine_00074,
+    Machine_00074_ReadDTO,
+    Machine_00074_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00074(Controller):
+    dto = Machine_00074_WriteDTO
+    return_dto = Machine_00074_ReadDTO
+    path = "/company/{company_id:int}/machines-00074"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00074"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00074]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00074]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00075.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00075 import (
+    Machine_00075,
+    Machine_00075_ReadDTO,
+    Machine_00075_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00075(Controller):
+    dto = Machine_00075_WriteDTO
+    return_dto = Machine_00075_ReadDTO
+    path = "/company/{company_id:int}/machines-00075"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00075"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00075]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00075]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00076.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00076 import (
+    Machine_00076,
+    Machine_00076_ReadDTO,
+    Machine_00076_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00076(Controller):
+    dto = Machine_00076_WriteDTO
+    return_dto = Machine_00076_ReadDTO
+    path = "/company/{company_id:int}/machines-00076"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00076"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00076]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00076]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00077.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00077 import (
+    Machine_00077,
+    Machine_00077_ReadDTO,
+    Machine_00077_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00077(Controller):
+    dto = Machine_00077_WriteDTO
+    return_dto = Machine_00077_ReadDTO
+    path = "/company/{company_id:int}/machines-00077"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00077"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00077]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00077]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00078.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00078 import (
+    Machine_00078,
+    Machine_00078_ReadDTO,
+    Machine_00078_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00078(Controller):
+    dto = Machine_00078_WriteDTO
+    return_dto = Machine_00078_ReadDTO
+    path = "/company/{company_id:int}/machines-00078"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00078"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00078]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00078]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00079.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00079 import (
+    Machine_00079,
+    Machine_00079_ReadDTO,
+    Machine_00079_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00079(Controller):
+    dto = Machine_00079_WriteDTO
+    return_dto = Machine_00079_ReadDTO
+    path = "/company/{company_id:int}/machines-00079"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00079"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00079]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00079]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00080.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00080 import (
+    Machine_00080,
+    Machine_00080_ReadDTO,
+    Machine_00080_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00080(Controller):
+    dto = Machine_00080_WriteDTO
+    return_dto = Machine_00080_ReadDTO
+    path = "/company/{company_id:int}/machines-00080"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00080"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00080]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00080]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00081.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00081 import (
+    Machine_00081,
+    Machine_00081_ReadDTO,
+    Machine_00081_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00081(Controller):
+    dto = Machine_00081_WriteDTO
+    return_dto = Machine_00081_ReadDTO
+    path = "/company/{company_id:int}/machines-00081"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00081"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00081]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00081]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00082.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00082 import (
+    Machine_00082,
+    Machine_00082_ReadDTO,
+    Machine_00082_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00082(Controller):
+    dto = Machine_00082_WriteDTO
+    return_dto = Machine_00082_ReadDTO
+    path = "/company/{company_id:int}/machines-00082"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00082"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00082]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00082]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00083.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00083 import (
+    Machine_00083,
+    Machine_00083_ReadDTO,
+    Machine_00083_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00083(Controller):
+    dto = Machine_00083_WriteDTO
+    return_dto = Machine_00083_ReadDTO
+    path = "/company/{company_id:int}/machines-00083"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00083"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00083]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00083]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00084.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00084 import (
+    Machine_00084,
+    Machine_00084_ReadDTO,
+    Machine_00084_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00084(Controller):
+    dto = Machine_00084_WriteDTO
+    return_dto = Machine_00084_ReadDTO
+    path = "/company/{company_id:int}/machines-00084"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00084"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00084]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00084]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00085.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00085 import (
+    Machine_00085,
+    Machine_00085_ReadDTO,
+    Machine_00085_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00085(Controller):
+    dto = Machine_00085_WriteDTO
+    return_dto = Machine_00085_ReadDTO
+    path = "/company/{company_id:int}/machines-00085"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00085"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00085]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00085]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00086.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00086 import (
+    Machine_00086,
+    Machine_00086_ReadDTO,
+    Machine_00086_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00086(Controller):
+    dto = Machine_00086_WriteDTO
+    return_dto = Machine_00086_ReadDTO
+    path = "/company/{company_id:int}/machines-00086"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00086"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00086]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00086]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)

app/controllers/mass_machine_00087.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, Optional
+
+from litestar import Controller, get
+from litestar.contrib.repository.filters import LimitOffset, SearchFilter
+from litestar.di import Provide
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.company import Company
+from app.domain.mass_machine_00087 import (
+    Machine_00087,
+    Machine_00087_ReadDTO,
+    Machine_00087_WriteDTO,
+    Repository,
+    Service,
+)
+from app.lib.responses import ObjectListResponse, ObjectResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+DETAIL_ROUTE = "/{machine_id:int}"
+
+
+async def provides_service(db_session: AsyncSession, company_id: int) -> Service:
+    """Constructs repository and service objects for the request."""
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    company = await company_service.get(company_id)
+    return Service(Repository(session=db_session, company=company))
+
+
+async def get_company(db_session: AsyncSession, company_id: int) -> Company:
+    from app.controllers.company import provides_service
+
+    company_service = provides_service(db_session)
+    return await company_service.get(company_id)
+
+
+class MachineController_00087(Controller):
+    dto = Machine_00087_WriteDTO
+    return_dto = Machine_00087_ReadDTO
+    path = "/company/{company_id:int}/machines-00087"
+    dependencies = {
+        "service": Provide(provides_service),
+    }
+    tags = ["Machines-00087"]
+
+    @get()
+    async def get_machines(
+        self,
+        service: Service,
+        search: Optional[str] = None,
+    ) -> ObjectListResponse[Machine_00087]:
+        filters = [
+            LimitOffset(limit=20, offset=0),
+        ]
+
+        if search is not None:
+            filters.append(
+                SearchFilter(
+                    field_name="caption",
+                    value=search,
+                ),
+            )
+
+        content = await service.list(*filters)
+        return ObjectListResponse(content=content)
+
+    @get(DETAIL_ROUTE)
+    async def get_machine(
+        self, service: Service, machine_id: int
+    ) -> ObjectResponse[Machine_00087]:
+        content = await service.get(machine_id)
+        return ObjectResponse(content=content)