Fulfillment-Backend/schemas/card.py

from datetime import datetime, date
from typing import List, Optional, Union

from pydantic import constr

from schemas.attribute import CardAttributeSchema
from schemas.base import BaseSchema, OkMessageSchema, PaginationInfoSchema
from schemas.billing import CardBillRequestSchema
from schemas.board import BoardSchema
from schemas.card_tag import CardTagSchema
from schemas.chat import ChatSchema
from schemas.client import ClientSchema
from schemas.group import CardGroupSchema
from schemas.marketplace import BaseMarketplaceSchema
from schemas.product import ProductSchema
from schemas.service import ServiceSchema
from schemas.shipping import PalletSchema, BoxSchema
from schemas.shipping_warehouse import ShippingWarehouseSchema, BaseShippingWarehouseSchema
from schemas.status import StatusSchema, CardStatusHistorySchema
from schemas.user import UserSchema


# region Entities

class BaseSchemaWithAttributes(BaseSchema):
    attributes: dict[str, Union[bool, str, int, float, date, datetime, None]] = None

    def validate_attributes(cls, value):
        for attr_name, attr_value in value.items():
            if not isinstance(attr_value, (str, int, float, date, datetime, None)):
                raise ValueError(f"Invalid type for attribute '{attr_name}': {type(attr_value)}")
        return value


class CardSummary(BaseSchema):
    id: int
    name: str
    client_name: Optional[str]
    created_at: datetime
    status: StatusSchema
    board: BoardSchema
    total_price: int
    rank: int
    base_marketplace: Optional[BaseMarketplaceSchema] = None
    total_products: int
    tags: list[CardTagSchema]
    attributes: list[CardAttributeSchema]

    shipment_warehouse_id: Optional[int]
    shipment_warehouse_name: Optional[str]

    bill_request: Optional[CardBillRequestSchema] = None
    group: Optional[CardGroupSchema] = None


class CardServiceSchema(BaseSchema):
    service: ServiceSchema
    quantity: int
    price: int
    employees: List[UserSchema]
    is_fixed_price: bool


class CardProductServiceSchema(BaseSchema):
    service: ServiceSchema
    price: int
    employees: List[UserSchema]
    is_fixed_price: bool


class CardProductSchema(BaseSchema):
    product: ProductSchema
    services: List[CardProductServiceSchema]
    quantity: int
    comment: str = ""


class CardEmployeesSchema(BaseSchema):
    user: UserSchema
    created_at: datetime


class BaseCardSchema(BaseSchema):
    id: int
    name: str
    comment: str
    created_at: datetime
    status: StatusSchema
    board: BoardSchema
    status_history: List[CardStatusHistorySchema]
    is_deleted: bool
    is_completed: bool

    is_services_profit_accounted: bool
    is_locked: bool
    services: List[CardServiceSchema]
    products: List[CardProductSchema]
    client_id: Optional[int]
    client: Optional[ClientSchema]
    shipping_warehouse: Optional[Union[ShippingWarehouseSchema, str]] = None
    bill_request: Optional[CardBillRequestSchema] = None
    group: Optional[CardGroupSchema] = None
    manager: Optional[UserSchema] = None
    pallets: List[PalletSchema] = []
    boxes: List[BoxSchema] = []
    employees: List[CardEmployeesSchema] = []
    tags: List[CardTagSchema] = []


class CardSchema(BaseCardSchema):
    attributes: list[CardAttributeSchema]
    chat: Optional[ChatSchema]


class CardGeneralInfoSchema(BaseSchemaWithAttributes):
    name: str
    is_deleted: bool
    is_completed: bool
    comment: str
    manager: Optional[UserSchema] = None
    board_id: int
    status_id: int
    client_id: Optional[int]
    tags: List[str]


class ProductsAndServicesGeneralInfoSchema(BaseSchema):
    shipping_warehouse: Optional[str] = None
    is_services_profit_accounted: bool


class OptionalShippingWarehouseSchema(BaseShippingWarehouseSchema):
    id: Optional[int] = None


class ParsedCityBreakdownSchema(BaseSchema):
    base_marketplace: BaseMarketplaceSchema
    shipping_warehouse: OptionalShippingWarehouseSchema
    quantity: int


class ParsedProductRowSchema(BaseSchema):
    barcode: str
    products: list[ProductSchema]
    breakdowns: list[ParsedCityBreakdownSchema]


class CityBreakdownFromExcelSchema(BaseSchema):
    base_marketplace: BaseMarketplaceSchema
    shipping_warehouse: OptionalShippingWarehouseSchema
    quantity: int


class ProductFromExcelSchema(BaseSchema):
    product_id: int
    cities_breakdown: list[CityBreakdownFromExcelSchema]


# endregion Entities

# region Requests
class CardChangeStatusRequest(BaseSchema):
    card_id: int
    new_status: int


class GetCardSummariesRequest(BaseSchema):
    full: bool
    card_id: Optional[int | str] = None
    card_name: Optional[str] = None
    marketplace_key: Optional[str] = None
    shipping_warehouse_id: Optional[int] = None
    client_id: Optional[int] = None
    project_id: Optional[int] = None
    board_id: Optional[int] = None
    status_id: Optional[int] = None


class CardCreateRequest(BaseSchema):
    name: str
    status_id: int


class CardQuickCreateRequest(BaseSchema):
    name: constr(strip_whitespace=True)
    client_name: Optional[constr(strip_whitespace=True)]
    comment: str
    acceptance_date: datetime
    shipping_warehouse: Optional[constr(strip_whitespace=True)]
    base_marketplace: Optional[BaseMarketplaceSchema]
    status_id: int


class CardAddServicesRequest(BaseSchema):
    card_id: int
    services: list[CardServiceSchema]


class CardUpdateServiceQuantityRequest(BaseSchema):
    card_id: int
    service_id: int
    quantity: int


class CardUpdateServiceRequest(BaseSchema):
    card_id: int
    service: CardServiceSchema


class CardAddServiceRequest(BaseSchema):
    card_id: int
    service_id: int
    quantity: int
    price: int


class CardDeleteServiceRequest(BaseSchema):
    card_id: int
    service_id: int


class CardDeleteServicesRequest(BaseSchema):
    card_id: int
    service_ids: List[int]


class CardUpdateProductQuantityRequest(BaseSchema):
    card_id: int
    product_id: int
    quantity: int


class CardAddProductRequest(BaseSchema):
    card_id: int
    product: CardProductSchema


class CardDeleteProductRequest(BaseSchema):
    card_id: int
    product_id: int


class CardDeleteProductsRequest(BaseSchema):
    card_id: int
    product_ids: List[int]


class CardUpdateGeneralInfoRequest(BaseSchema):
    card_id: int
    data: CardGeneralInfoSchema


class ProductsAndServicesGeneralInfoRequest(BaseSchema):
    card_id: int
    data: ProductsAndServicesGeneralInfoSchema


class UpdateCardManagerRequest(BaseSchema):
    card_id: int
    manager_id: Optional[int]


class UpdateCardClientRequest(BaseSchema):
    card_id: int
    client_id: int


class CardSummaryReorderRequest(BaseSchema):
    card_id: int
    status_id: int
    index: int
    deadline: datetime | None = None
    comment: str | None = None


class CardDeleteRequest(BaseSchema):
    card_id: int


class CardUpdateProductRequest(BaseSchema):
    card_id: int
    product: CardProductSchema


class CardServicesCopyRequest(BaseSchema):
    card_id: int
    source_product_id: int
    destination_product_ids: List[int]


class CardProductAddKitRequest(BaseSchema):
    card_id: int
    product_id: int
    kit_id: int


class CardAddKitRequest(BaseSchema):
    card_id: int
    kit_id: int


class CardCreateGuestUrlRequest(BaseSchema):
    card_id: int


class CardCompleteRequest(BaseSchema):
    card_id: int


class CardPrefillRequest(BaseSchema):
    old_card_id: int
    new_card_id: int


class CardRecalculatePriceRequest(BaseSchema):
    card_id: int


class ManageEmployeeRequest(BaseSchema):
    card_id: int
    user_id: int
    is_assign: bool


class CreateCardsFromExcelRequest(BaseSchema):
    client_id: int
    status_id: int
    products: list[ProductFromExcelSchema]


# endregion Requests

# region Responses
class CardUpdateProductQuantityResponse(OkMessageSchema):
    pass


class CardDeleteServicesResponse(OkMessageSchema):
    pass


class CardGetAllResponse(BaseSchema):
    cards: List[CardSchema]


class CardChangeStatusResponse(BaseSchema):
    ok: bool


class CardCreateResponse(BaseSchema):
    ok: bool


class CardQuickCreateResponse(BaseSchema):
    card_id: int


class CardSummaryResponse(BaseSchema):
    summaries: List[CardSummary]
    pagination_info: PaginationInfoSchema


class CardAddServicesResponse(BaseSchema):
    ok: bool
    message: str


class CardUpdateServiceQuantityResponse(BaseSchema):
    ok: bool
    message: str


class CardUpdateServiceResponse(OkMessageSchema):
    pass


class CardAddServiceResponse(OkMessageSchema):
    pass


class CardDeleteServiceResponse(OkMessageSchema):
    pass


class CardDeleteProductResponse(OkMessageSchema):
    pass


class CardDeleteProductsResponse(OkMessageSchema):
    pass


class CardAddProductResponse(OkMessageSchema):
    pass


class CardUpdateGeneralInfoResponse(OkMessageSchema):
    pass


class ProductsAndServicesGeneralInfoResponse(OkMessageSchema):
    pass


class UpdateCardManagerResponse(OkMessageSchema):
    pass


class UpdateCardClientResponse(OkMessageSchema):
    pass


class CardSummaryReorderResponse(OkMessageSchema):
    pass


class CardDeleteResponse(OkMessageSchema):
    pass


class CardUpdateProductResponse(OkMessageSchema):
    pass


class CardServicesCopyResponse(OkMessageSchema):
    pass


class CardProductAddKitResponse(OkMessageSchema):
    pass


class CardAddKitResponse(OkMessageSchema):
    pass


class CardCreateGuestUrlResponse(OkMessageSchema):
    url: str


class CardCompleteResponse(OkMessageSchema):
    pass


class CardPrefillResponse(OkMessageSchema):
    pass


class CardRecalculatePriceResponse(OkMessageSchema):
    pass


class ManageEmployeeResponse(OkMessageSchema):
    pass


class GetAvailableEmployeesToAssignResponse(BaseSchema):
    employees: list[UserSchema]


class ParseCardsExcelResponse(BaseSchema):
    rows: list[ParsedProductRowSchema]
    errors: list[str]


class CreateCardsFromExcelResponse(OkMessageSchema):
    pass

# endregion Responses