refactor: remove unused method

src/api/presentation/routes/cart/cart.py

@@ -44,19 +44,6 @@ async def get_order_by_id(id: str) -> OrderResponseDto:
         logger.exception(f"Server Error | {id=}")
         raise HTTPException(status_code=500, detail=exc.args)
 
-
-@router.put("/api/v1/order/{id}")
-async def update_order(id: str, order_request: CreateOrderRequestDto) -> OrderResponseDto:
-    try:
-        order_request_dict = order_request.model_dump()
-        return CartController.update_order(order_id=id, request_data=order_request_dict)
-    except ValidationError as pydantic_exc:
-        raise HTTPException(status_code=400, detail=pydantic_exc.errors())
-    except Exception as exc:
-        logger.exception(f"Server Error | {id=} {order_request=}")
-        raise HTTPException(status_code=500, detail=exc.args)
-
-
 @router.put("/api/v1/order/{id}/status")
 async def update_order_status(id: str, new_status: str) -> OrderResponseDto:
     try:

src/cart/cart_controller.py

@@ -52,19 +52,6 @@ def get_order_by_id(order_id: str):
         order = CartUseCase.get_order_by_id(order_id=order_id, gateway=cart_gateway)
         return presenter.present(order)
 
-    @staticmethod
-    def update_order(order_id: str, request_data: Dict):
-        uow: ICartUnitOfWork = CartPostgreSqlUow(session_factory=postgresql_session_factory())
-        cart_gateway: ICartGateway = PostgreSqlOrderGateway(uow)
-        product_uow: IProductUnitOfWork = ProductPostgreSqlUow(session_factory=postgresql_session_factory())
-        product_gateway: IProductGateway = PostgreSqlProductGateway(product_uow)
-        presenter: ICartPresenter = PydanticCartPresenter()
-        order = CartUseCase.update_order(order_id=order_id,
-                                         request_data=request_data,
-                                         gateway=cart_gateway,
-                                         product_gateway=product_gateway)
-        return presenter.present(order)
-
     @staticmethod
     def update_order_status(order_id: str, new_status: str):
         uow: ICartUnitOfWork = CartPostgreSqlUow(session_factory=postgresql_session_factory())

src/cart/use_cases/cart.py

@@ -1,10 +1,9 @@
 from datetime import datetime
-from typing import Dict, Any, List
+from typing import Dict, List
 
 from src.cart.domain.entities.order import Order
 from src.cart.domain.entities.order_product import OrderProduct
 from src.cart.domain.enums.order_status import OrderStatus
-from src.cart.domain.validators.order_product_validator import OrderProductValidator
 from src.cart.domain.validators.order_validator import OrderValidator
 from src.cart.exceptions import (ClientError,
                                  ProductNotFoundError,
@@ -63,51 +62,10 @@ def get_all_orders(gateway: ICartGateway):
     def get_order_by_id(order_id: str, gateway: ICartGateway):
         return gateway.get_order_by_id(order_id=order_id)
 
-    @staticmethod
-    def update_order(order_id: str,
-                     request_data: Dict,
-                     gateway: ICartGateway,
-                     product_gateway: IProductGateway):
-        order = CartUseCase.get_order_by_id(order_id, gateway)
-        if not order:
-            raise OrderNotFoundError(order=order_id)
-
-        products_sku = [p.product for p in order.products]
-        for product_required in request_data['products']:
-            sku_required = product_required['sku']
-            if sku_required not in products_sku:
-                CartUseCase.add_new_product_to_order(original_order_products=order.products,
-                                                     product_gateway=product_gateway,
-                                                     updated_order_products_sku=product_required)
-            else:
-                CartUseCase.update_order_products(original_order_products=order.products,
-                                                  product_gateway=product_gateway,
-                                                  updated_order_products_sku=product_required)
-
-        order.order_status = request_data['order_status']
-        OrderValidator.validate(order)
-        return gateway.create_update_order(order)
-
     @staticmethod
     def delete_order(order_id: str, gateway: ICartGateway):
         gateway.delete_order(order_id=order_id)
 
-    @staticmethod
-    def update_order_products(original_order_products: list[OrderProduct],
-                              product_gateway: IProductGateway,
-                              updated_order_products_sku: Dict[str, Any]):
-
-        for original_order_product in original_order_products:
-            product = original_order_product.product
-            updated_product = updated_order_products_sku.get(product.sku)
-            product_entity = product_gateway.get_product_by_sku(product.sku)
-            quantity = updated_product['quantity']
-            original_order_product.quantity = quantity
-            original_order_product.observation = updated_product.get('observation')
-            OrderProductValidator.validate(original_order_product)
-            product_entity.stock -= quantity if product_entity.stock - quantity > 0 else 0
-            product_gateway.create_update_product(product=product_entity)
-
     @staticmethod
     def add_new_product_to_order(original_order_products, product_gateway, updated_order_products_sku):
         product_entity = product_gateway.get_product_by_sku(updated_order_products_sku['sku'])