._.

app/infrastructure/database/database.py

@@ -14,7 +14,7 @@ SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 
 def init_db():
-    import app.infrastructure.database.models.accessories
+    import app.infrastructure.database.models.accessory
     import app.infrastructure.database.models.deliveries
     import app.infrastructure.database.models.orders
     import app.infrastructure.database.models.roles

app/infrastructure/database/models/accessory.py

@@ -4,7 +4,7 @@ from sqlalchemy.orm import relationship
 from app.infrastructure.database.models import Base
 
 
-class Accessories(Base):
+class Accessory(Base):
     __tablename__ = 'accessories'
 
     id = Column(Integer, primary_key=True, autoincrement=True)

app/infrastructure/database/models/storage_accessories.py

@@ -12,10 +12,10 @@ class StorageAccessories(Base):
     change_datetime = Column(DateTime)
 
     storage_id = Column(Integer, ForeignKey('storages.id'))
-    accessories_id = Column(Integer, ForeignKey('accessories.id'))
+    accessory_id = Column(Integer, ForeignKey('accessories.id'))
 
     storage = relationship('Storage', back_populates='storage_accessories')
-    accessories = relationship('Accessories', back_populates='storage_accessories')
+    accessory = relationship('Accessories', back_populates='storage_accessories')
 
     deliveries = relationship('Delivery', back_populates='storage_accessories')
 

app/infrastructure/database/repository/accessory_repository.py

@@ -0,0 +1,30 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.accessory import Accessory
+
+class AccessoriesRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Accessory).all()
+
+    def get_by_id(self, accessory_id: int):
+        return self.db.query(Accessory).filter(Accessory.id == accessory_id).first()
+
+    def create(self, accessory: Accessory):
+        self.db.add(accessory)
+        self.db.commit()
+        self.db.refresh(accessory)
+        return accessory
+
+    def update(self, accessory: Accessory):
+        self.db.commit()
+        return accessory
+
+    def delete(self, accessory_id: int):
+        accessory = self.db.query(Accessory).filter(Accessory.id == accessory_id).first()
+        if accessory:
+            self.db.delete(accessory)
+            self.db.commit()
+            return accessory
+        return None

app/infrastructure/database/repository/delivery_repository.py

@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.deliveries import Delivery
+
+
+class DeliveriesRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Delivery).all()
+
+    def get_by_id(self, delivery_id: int):
+        return self.db.query(Delivery).filter(Delivery.id == delivery_id).first()
+
+    def create(self, delivery: Delivery):
+        self.db.add(delivery)
+        self.db.commit()
+        self.db.refresh(delivery)
+        return delivery
+
+    def update(self, delivery: Delivery):
+        self.db.commit()
+        return delivery
+
+    def delete(self, delivery_id: int):
+        delivery = self.db.query(Delivery).filter(Delivery.id == delivery_id).first()
+        if delivery:
+            self.db.delete(delivery)
+            self.db.commit()
+            return delivery
+        return None

app/infrastructure/database/repository/orders_repository.py

@@ -0,0 +1,30 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.orders import Order
+
+class OrdersRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Order).all()
+
+    def get_by_id(self, order_id: int):
+        return self.db.query(Order).filter(Order.id == order_id).first()
+
+    def create(self, order: Order):
+        self.db.add(order)
+        self.db.commit()
+        self.db.refresh(order)
+        return order
+
+    def update(self, order: Order):
+        self.db.commit()
+        return order
+
+    def delete(self, order_id: int):
+        order = self.db.query(Order).filter(Order.id == order_id).first()
+        if order:
+            self.db.delete(order)
+            self.db.commit()
+            return order
+        return None

app/infrastructure/database/repository/roles_repository.py

@@ -0,0 +1,30 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.roles import Role
+
+class RolesRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Role).all()
+
+    def get_by_id(self, role_id: int):
+        return self.db.query(Role).filter(Role.id == role_id).first()
+
+    def create(self, role: Role):
+        self.db.add(role)
+        self.db.commit()
+        self.db.refresh(role)
+        return role
+
+    def update(self, role: Role):
+        self.db.commit()
+        return role
+
+    def delete(self, role_id: int):
+        role = self.db.query(Role).filter(Role.id == role_id).first()
+        if role:
+            self.db.delete(role)
+            self.db.commit()
+            return role
+        return None

app/infrastructure/database/repository/statuses_repository.py

@@ -0,0 +1,30 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.statuses import Status
+
+class StatusesRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Status).all()
+
+    def get_by_id(self, status_id: int):
+        return self.db.query(Status).filter(Status.id == status_id).first()
+
+    def create(self, status: Status):
+        self.db.add(status)
+        self.db.commit()
+        self.db.refresh(status)
+        return status
+
+    def update(self, status: Status):
+        self.db.commit()
+        return status
+
+    def delete(self, status_id: int):
+        status = self.db.query(Status).filter(Status.id == status_id).first()
+        if status:
+            self.db.delete(status)
+            self.db.commit()
+            return status
+        return None

app/infrastructure/database/repository/steps_repository.py

@@ -0,0 +1,30 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.steps import Step
+
+class StepsRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Step).all()
+
+    def get_by_id(self, step_id: int):
+        return self.db.query(Step).filter(Step.id == step_id).first()
+
+    def create(self, step: Step):
+        self.db.add(step)
+        self.db.commit()
+        self.db.refresh(step)
+        return step
+
+    def update(self, step: Step):
+        self.db.commit()
+        return step
+
+    def delete(self, step_id: int):
+        step = self.db.query(Step).filter(Step.id == step_id).first()
+        if step:
+            self.db.delete(step)
+            self.db.commit()
+            return step
+        return None

app/infrastructure/database/repository/storage_accessories_repository.py

@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.storage_accessories import StorageAccessories
+
+
+class StorageAccessoriesRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(StorageAccessories).all()
+
+    def get_by_id(self, storage_accessories_id: int):
+        return self.db.query(StorageAccessories).filter(StorageAccessories.id == storage_accessories_id).first()
+
+    def create(self, storage_accessories: StorageAccessories):
+        self.db.add(storage_accessories)
+        self.db.commit()
+        self.db.refresh(storage_accessories)
+        return storage_accessories
+
+    def update(self, storage_accessories: StorageAccessories):
+        self.db.commit()
+        return storage_accessories
+
+    def delete(self, storage_accessories_id: int):
+        storage_accessories = self.db.query(StorageAccessories).filter(
+            StorageAccessories.id == storage_accessories_id).first()
+        if storage_accessories:
+            self.db.delete(storage_accessories)
+            self.db.commit()
+            return storage_accessories
+        return None

app/infrastructure/database/repository/storage_repository.py

@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.storages import Storage
+
+
+class StorageRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Storage).all()
+
+    def get_by_id(self, storage_id: int):
+        return self.db.query(Storage).filter(Storage.id == storage_id).first()
+
+    def create(self, storage: Storage):
+        self.db.add(storage)
+        self.db.commit()
+        self.db.refresh(storage)
+        return storage
+
+    def update(self, storage: Storage):
+        self.db.commit()
+        return storage
+
+    def delete(self, storage_id: int):
+        storage = self.db.query(Storage).filter(Storage.id == storage_id).first()
+        if storage:
+            self.db.delete(storage)
+            self.db.commit()
+            return storage
+        return None

app/infrastructure/database/repository/user_repository.py

@@ -0,0 +1,34 @@
+from sqlalchemy.orm import Session
+from app.infrastructure.database.models.users import User
+
+
+class UserRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(User).all()
+
+    def get_by_id(self, user_id: int):
+        return self.db.query(User).filter(User.id == user_id).first()
+
+    def get_by_login(self, login: str):
+        return self.db.query(User).filter(User.login == login).first()
+
+    def create(self, user: User):
+        self.db.add(user)
+        self.db.commit()
+        self.db.refresh(user)
+        return user
+
+    def update(self, user: User):
+        self.db.commit()
+        return user
+
+    def delete(self, user_id: int):
+        user = self.db.query(User).filter(User.id == user_id).first()
+        if user:
+            self.db.delete(user)
+            self.db.commit()
+            return user
+        return None