brewman/brewman/schemas/reports.py

import uuid
from decimal import Decimal
from typing import List, Optional
from datetime import datetime, date
from pydantic import BaseModel, Field, validator

from brewman.schemas import to_camel
from brewman.schemas.master import AccountLink, ProductLink


class LedgerItem(BaseModel):
    id_: Optional[uuid.UUID]
    date_: date
    name: str
    url: List[str]
    type_: str
    narration: str
    debit: Decimal = Field(multiple_of=0.01)
    credit: Decimal = Field(multiple_of=0.01)
    posted: bool

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}


class Ledger(BaseModel):
    start_date: date
    finish_date: date
    account: Optional[AccountLink]
    body: List[LedgerItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class BalanceSheetItem(BaseModel):
    name: Optional[str]
    group: Optional[str]
    amount: Optional[Decimal]
    sub_amount: Optional[Decimal]
    order: int

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class BalanceSheet(BaseModel):
    date_: date
    body: List[BalanceSheetItem]
    footer: Optional[BalanceSheetItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class CashFlowItem(BaseModel):
    name: str
    url: Optional[List[str]]
    amount: Decimal = Field(multiple_of=0.01)

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class CashFlowBody(BaseModel):
    operating: List[CashFlowItem]
    investing: List[CashFlowItem]
    financing: List[CashFlowItem]
    details: List[CashFlowItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class CashFlow(BaseModel):
    start_date: date
    finish_date: date
    body: CashFlowBody
    footer: Optional[List[CashFlowItem]]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class ClosingStockItem(BaseModel):
    product: str
    group: str
    quantity: Decimal
    amount: Decimal

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class ClosingStock(BaseModel):
    date_: date
    body: List[ClosingStockItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class DaybookItem(BaseModel):
    id_: Optional[uuid.UUID]
    date_: date
    url: List[str]
    type_: str
    narration: str
    debit_text: Optional[str]
    debit: Optional[Decimal] = Field(multiple_of=0.01)
    credit_text: Optional[str]
    credit: Optional[Decimal] = Field(multiple_of=0.01)
    posted: bool

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}


class Daybook(BaseModel):
    start_date: date
    finish_date: date
    body: List[DaybookItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class NetTransactionsItem(BaseModel):
    type_: str
    name: str
    debit: Optional[Decimal] = Field(multiple_of=0.01)
    credit: Optional[Decimal] = Field(multiple_of=0.01)

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}


class NetTransactions(BaseModel):
    start_date: date
    finish_date: date
    body: List[NetTransactionsItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class ProductLedgerItem(BaseModel):
    id_: Optional[uuid.UUID]
    date_: date
    name: str
    url: List[str]
    type_: str
    narration: str
    debit_quantity: Optional[Decimal]
    debit_amount: Optional[Decimal]
    credit_quantity: Optional[Decimal]
    credit_amount: Optional[Decimal]
    running_quantity: Decimal
    running_amount: Decimal
    posted: bool

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}


class ProductLedger(BaseModel):
    start_date: date
    finish_date: date
    product: Optional[ProductLink]
    body: List[ProductLedgerItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class ProfitLossItem(BaseModel):
    group: Optional[str]
    name: Optional[str]
    amount: Optional[Decimal]
    total: Optional[Decimal]
    order: int

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}


class ProfitLoss(BaseModel):
    start_date: date
    finish_date: date
    body: List[ProfitLossItem]
    footer: Optional[ProfitLossItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class PurchaseEntriesItem(BaseModel):
    date_: date
    url: List[str]
    supplier: str
    product: str
    quantity: Decimal
    rate: Decimal
    tax: Decimal
    discount: Decimal
    amount: Decimal

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class PurchaseEntries(BaseModel):
    start_date: date
    finish_date: date
    body: List[PurchaseEntriesItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class PurchasesItem(BaseModel):
    name: str
    quantity: Decimal
    rate: Decimal
    amount: Decimal
    url: List[str]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class Purchases(BaseModel):
    start_date: date
    finish_date: date
    body: List[PurchasesItem]
    footer: Optional[PurchasesItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class RawMaterialCostItem(BaseModel):
    name: Optional[str]
    issue: Optional[Decimal]
    sale: Optional[Decimal]
    rmc: Optional[Decimal]
    url: Optional[List[str]]

    group: Optional[str]
    quantity: Optional[Decimal]
    net: Optional[Decimal]
    gross: Optional[Decimal]

    heading: Optional[bool]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class RawMaterialCost(BaseModel):
    id_: Optional[uuid.UUID]
    start_date: date
    finish_date: date
    body: List[RawMaterialCostItem]
    footer: Optional[RawMaterialCostItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class StockMovementItem(BaseModel):
    id_: uuid.UUID
    group: str
    name: str
    opening: Decimal
    purchase: Decimal
    issue: Decimal
    closing: Decimal
    url: List[str]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class StockMovement(BaseModel):
    start_date: date
    finish_date: date
    body: List[StockMovementItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("start_date", pre=True)
    def parse_start_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    @validator("finish_date", pre=True)
    def parse_finish_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class TrialBalanceItem(BaseModel):
    type_: Optional[str]
    name: Optional[str]
    debit: Optional[Decimal]
    credit: Optional[Decimal]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel


class TrialBalance(BaseModel):
    date_: date
    body: List[TrialBalanceItem]

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()


class Unposted(BaseModel):
    id_: uuid.UUID
    date_: date
    url: List[str]
    type_: str
    narration: str
    debit_name: str
    debit_amount: Decimal
    credit_name: str
    credit_amount: Decimal

    @validator("date_", pre=True)
    def parse_date(cls, value):
        if isinstance(value, date):
            return value
        return datetime.strptime(value, "%d-%b-%Y").date()

    class Config:
        anystr_strip_whitespace = True
        alias_generator = to_camel
        json_encoders = {date: lambda v: v.strftime("%d-%b-%Y")}