diff --git a/main.py b/main.py index 8e34220..9329eeb 100644 --- a/main.py +++ b/main.py @@ -45,6 +45,7 @@ routers_list = [ routers.time_tracking_router, routers.billing_router, routers.task_router, + routers.statistics_router, ] for router in routers_list: app.include_router(router) diff --git a/routers/__init__.py b/routers/__init__.py index 000a693..73afc8c 100644 --- a/routers/__init__.py +++ b/routers/__init__.py @@ -13,3 +13,4 @@ from .payroll import payroll_router from .time_tracking import time_tracking_router from .billing import billing_router from .task import task_router +from .statistics import statistics_router \ No newline at end of file diff --git a/routers/statistics.py b/routers/statistics.py new file mode 100644 index 0000000..5906eed --- /dev/null +++ b/routers/statistics.py @@ -0,0 +1,27 @@ +from typing import Annotated + +from fastapi import APIRouter, Depends +from sqlalchemy.ext.asyncio import AsyncSession + +from backend.session import get_session +from schemas.statistics import GetProfitDataRequest, GetProfitDataResponse +from services.auth import authorized_user +from services.statistics import StatisticsService + +statistics_router = APIRouter( + prefix="/statistics", + tags=["statistics"], + dependencies=[Depends(authorized_user)] +) + + +@statistics_router.post( + '/get-profit-data', + response_model=GetProfitDataResponse, + operation_id='get_profit_data', +) +async def get_profit_data( + session: Annotated[AsyncSession, Depends(get_session)], + request: GetProfitDataRequest +): + return await StatisticsService(session).get_profit_data(request) diff --git a/schemas/statistics.py b/schemas/statistics.py new file mode 100644 index 0000000..5244d8c --- /dev/null +++ b/schemas/statistics.py @@ -0,0 +1,31 @@ +import datetime +from typing import List, Tuple + +from schemas.base import BaseSchema + +# region Entities + +class ProfitDataItem(BaseSchema): + date: datetime.date + revenue: float + profit: float + deals_count: int + +# endregion + +# region Requests + +class GetProfitDataRequest(BaseSchema): + date_range: Tuple[datetime.date, datetime.date] + client_id: int + base_marketplace_key: str + deal_status_id: int + +# endregion + +# region Responses + +class GetProfitDataResponse(BaseSchema): + data: List[ProfitDataItem] + +# endregion diff --git a/services/statistics.py b/services/statistics.py new file mode 100644 index 0000000..1492871 --- /dev/null +++ b/services/statistics.py @@ -0,0 +1,183 @@ +from collections import defaultdict +from datetime import datetime, timedelta + +from sqlalchemy import select, and_, union_all, func, Subquery + +from models import DealService, Deal, DealStatusHistory, DealProductService, DealProduct, Service +from schemas.statistics import GetProfitDataResponse, GetProfitDataRequest, ProfitDataItem +from services.base import BaseService + + +class StatisticsService(BaseService): + @staticmethod + def _get_sub_status_history(): + last_statuses = ( + select( + DealStatusHistory.deal_id, + func.max(DealStatusHistory.changed_at).label('changed_at') + ) + .group_by(DealStatusHistory.deal_id) + .subquery() + ) + return ( + select( + Deal.id.label('deal_id'), + last_statuses.c.changed_at, + Deal.current_status, + ) + .join(last_statuses, last_statuses.c.deal_id == Deal.id) + .subquery() + ) + + @staticmethod + def _get_filtered_sub_status_history(date_from: datetime.date, date_to: datetime.date): + sub_status_history = StatisticsService._get_sub_status_history() + return ( + select(sub_status_history) + .where(sub_status_history.c.changed_at.between(date_from, date_to)) + .subquery() + ) + + @staticmethod + def _fill_dates_gaps(rows, date_from: datetime.date, date_to: datetime.date) -> list[ProfitDataItem]: + dates = defaultdict(lambda: {"deals_count": 0, "profit": 0, "revenue": 0}) + for row in rows: + dates[row.changed_at.date()] = { + "deals_count": row.deals_count, + "profit": row.profit, + "revenue": row.revenue + } + + data = [] + while date_from < date_to: + data_item = ProfitDataItem( + date=date_from, + deals_count=dates[date_from]["deals_count"], + profit=dates[date_from]["profit"], + revenue=dates[date_from]["revenue"], + ) + data.append(data_item) + date_from += timedelta(days=1) + return data + + @staticmethod + def _get_stmt_deal_services(sub_filtered_status_history: Subquery): + return ( + select( + Deal.id.label("deal_id"), + func.date_trunc( + "day", + sub_filtered_status_history.c.changed_at, + ).label("changed_at"), + func.sum(DealService.price * DealService.quantity).label("revenue"), + func.sum((DealService.price - Service.cost) * DealService.quantity).label("profit"), + ) + .join(DealService, Deal.id == DealService.deal_id) + .join(Service, DealService.service_id == Service.id) + .join(sub_filtered_status_history, Deal.id == sub_filtered_status_history.c.deal_id) + .where(Deal.is_deleted == False) + .group_by(Deal.id, "changed_at") + ) + + @staticmethod + def _apply_filters(request: GetProfitDataRequest, stmt_deal_services, stmt_deal_product_services): + if request.client_id != -1: + stmt_deal_services = stmt_deal_services.where(Deal.client_id == request.client_id) + stmt_deal_product_services = stmt_deal_product_services.where(Deal.client_id == request.client_id) + + if request.base_marketplace_key != "all": + stmt_deal_services = stmt_deal_services.where(Deal.base_marketplace_key == request.base_marketplace_key) + stmt_deal_product_services = stmt_deal_product_services.where( + Deal.base_marketplace_key == request.base_marketplace_key) + + if request.deal_status_id != -1: + stmt_deal_services = stmt_deal_services.where(Deal.current_status == request.deal_status_id) + stmt_deal_product_services = stmt_deal_product_services.where(Deal.current_status == request.deal_status_id) + + return stmt_deal_services, stmt_deal_product_services + + @staticmethod + def _get_stmt_product_services(): + return ( + select( + Deal.id.label("deal_id"), + func.sum(DealProductService.price * DealProduct.quantity).label("revenue"), + func.sum((DealProductService.price - Service.cost) * DealProduct.quantity).label("profit"), + ) + .join(DealProduct, Deal.id == DealProduct.deal_id) + .join( + DealProductService, + and_( + DealProductService.deal_id == Deal.id, + DealProductService.product_id == DealProduct.product_id, + ) + ) + .join(Service, DealProductService.service_id == Service.id) + .where(Deal.is_deleted == False) + .group_by(Deal.id) + ) + + @staticmethod + def _group_by_date(stmt): + return ( + select( + stmt.c.changed_at, + func.count(stmt.c.deal_id).label("deals_count"), + func.sum(stmt.c.revenue).label("revenue"), + func.sum(stmt.c.profit).label("profit"), + ) + .group_by(stmt.c.changed_at) + .order_by(stmt.c.changed_at.asc()) + ) + + async def get_profit_data(self, request: GetProfitDataRequest) -> GetProfitDataResponse: + date_from, date_to = request.date_range + date_to += timedelta(days=1) + + sub_filtered_status_history = self._get_filtered_sub_status_history(date_from, date_to) + + stmt_deal_services = self._get_stmt_deal_services(sub_filtered_status_history) + + stmt_deal_product_services = self._get_stmt_product_services() + + stmt_deal_services, stmt_deal_product_services = self._apply_filters( + request, + stmt_deal_services, + stmt_deal_product_services + ) + + sub_deal_product_services = stmt_deal_product_services.subquery() + + stmt_join_deals_statuses = ( + select( + sub_deal_product_services.c.deal_id, + func.date_trunc( + "day", + sub_filtered_status_history.c.changed_at + ).label("changed_at"), + sub_deal_product_services.c.revenue.label("revenue"), + sub_deal_product_services.c.profit.label("profit"), + ) + .join(sub_filtered_status_history, sub_deal_product_services.c.deal_id == sub_filtered_status_history.c.deal_id) + ) + + stmt_union = union_all(stmt_deal_services, stmt_join_deals_statuses).subquery() + + sub_grouped_by_deals = ( + select( + stmt_union.c.deal_id, + stmt_union.c.changed_at, + func.sum(stmt_union.c.profit).label("profit"), + func.sum(stmt_union.c.revenue).label("revenue"), + ) + .group_by(stmt_union.c.deal_id, stmt_union.c.changed_at) + ) + + stmt_grouped_by_date = self._group_by_date(sub_grouped_by_deals) + + result = await self.session.execute(stmt_grouped_by_date) + rows = result.all() + + data = self._fill_dates_gaps(rows, date_from, date_to) + + return GetProfitDataResponse(data=data) diff --git a/test.py b/test.py index 8552340..33c65a4 100644 --- a/test.py +++ b/test.py @@ -1,21 +1,30 @@ import asyncio +import datetime from sqlalchemy.ext.asyncio import AsyncSession from backend.session import session_maker -from services.billing import BillingService +from schemas.statistics import GetProfitDataRequest +from services.statistics import StatisticsService async def main(): session: AsyncSession = session_maker() + request = GetProfitDataRequest( + date_range=( + datetime.date(2020, 1, 1), + datetime.date(2020, 1, 31), + ), + ) + try: - service = BillingService(session) + service = StatisticsService(session) - pdf_file = await service.create_billing_document_pdf(121) + result = await service.get_profit_data(request) - with open("report.pdf", "wb") as f: - f.write(pdf_file.getvalue()) + # for res in result: + # print(res) finally: await session.close()