feat: time tracking

services/payroll.py

@@ -167,11 +167,10 @@ class PayrollService(BaseService):
         )
         return response
 
-    async def _create_payment_record_hourly(
+    def get_amount(
             self,
-            creator: User,
             user: User,
-            record_schema: PaymentRecordCreateSchema
+            work_units: int
     ):
         pay_rate: PayRate = user.pay_rate
         overtime_threshold = 0
@@ -183,13 +182,22 @@ class PayrollService(BaseService):
             overtime_rate = pay_rate.overtime_rate
 
         if overtime_threshold == 0 or overtime_rate == 0:
-            base_units = record_schema.work_units
+            base_units = work_units
             overtime_units = 0
         else:
-            overtime_units = max(0, record_schema.work_units - overtime_threshold)
-            base_units = record_schema.work_units - overtime_units
+            overtime_units = max(0, work_units - overtime_threshold)
+            base_units = work_units - overtime_units
 
-        amount = pay_rate.base_rate * base_units + overtime_rate * overtime_units
+        return pay_rate.base_rate * base_units + overtime_rate * overtime_units
+
+    async def _create_payment_record_hourly(
+            self,
+            creator: User,
+            user: User,
+            record_schema: PaymentRecordCreateSchema
+    ):
+        pay_rate: PayRate = user.pay_rate
+        amount = self.get_amount(user, record_schema.work_units)
         payment_record_dict = record_schema.model_dump()
         del payment_record_dict['user']
         payment_record_dict.update({
@@ -202,54 +210,14 @@ class PayrollService(BaseService):
         stmt = (
             insert(
                 PaymentRecord
-            ).values(
+            )
+            .values(
                 **payment_record_dict
             )
         )
         await self.session.execute(stmt)
         await self.session.commit()
 
-    async def _create_payment_record_daily(
-            self,
-            creator: User,
-            user: User,
-            record_schema: PaymentRecordCreateSchema
-    ):
-        pay_rate: PayRate = user.pay_rate
-        amount = pay_rate.base_rate * record_schema.work_units
-        payment_record_dict = record_schema.model_dump()
-        del payment_record_dict['user']
-
-        payment_record_dict.update({
-            'created_by_user_id': creator.id,
-            'created_at': datetime.datetime.now(),
-            'payroll_scheme_key': pay_rate.payroll_scheme.key,
-            'amount': amount,
-            'user_id': record_schema.user.id
-
-        })
-
-    async def _create_payment_record_monthly(
-            self,
-            creator: User,
-
-            user: User,
-            record_schema: PaymentRecordCreateSchema
-    ) -> CreatePaymentRecordResponse:
-        pay_rate: PayRate = user.pay_rate
-        amount = pay_rate.base_rate * record_schema.work_units
-        payment_record_dict = record_schema.model_dump()
-        del payment_record_dict['user']
-
-        payment_record_dict.update({
-            'created_by_user_id': creator.id,
-            'created_at': datetime.datetime.now(),
-            'payroll_scheme_key': pay_rate.payroll_scheme.key,
-            'amount': amount,
-            'user_id': record_schema.user.id
-
-        })
-
     async def create_payment_record(
             self,
             request: CreatePaymentRecordRequest,
@@ -282,7 +250,8 @@ class PayrollService(BaseService):
             stmt = (
                 delete(
                     PaymentRecord
-                ).where(
+                )
+                .where(
                     PaymentRecord.id == request.payment_record_id
                 )
             )

services/time_tracking.py

@@ -0,0 +1,111 @@
+from collections import defaultdict
+
+from sqlalchemy import select, func
+from sqlalchemy.orm import joinedload
+
+from models import PaymentRecord, User
+from schemas.time_tracking import *
+from services.base import BaseService
+from services.payroll import PayrollService
+from services.user import UserService
+
+
+class TimeTrackingService(BaseService):
+    async def get_records(self, request: GetTimeTrackingRecordsRequest) -> GetTimeTrackingRecordsResponse:
+        stmt = (
+            select(
+                PaymentRecord,
+            )
+            .options(
+                joinedload(
+                    PaymentRecord.user
+                )
+            )
+            .where(
+                func.date(func.date_trunc('month', PaymentRecord.start_date)) == request.date,
+                func.date(func.date_trunc('month', PaymentRecord.end_date)) == request.date,
+                PaymentRecord.start_date == PaymentRecord.end_date,
+                # PaymentRecord.user_id.in_(request.user_ids)
+            )
+        )
+        query_result = (await self.session.scalars(stmt)).all()
+        records_dict = defaultdict(list)
+        users_dict = {}
+        amount_dict = defaultdict(list)
+        for payment_record in query_result:
+            user = UserSchema.model_validate(payment_record.user)
+            data = TimeTrackingData(
+                date=payment_record.start_date,
+                hours=payment_record.work_units,
+                amount=payment_record.amount
+            )
+            users_dict[user.id] = user
+            records_dict[user.id].append(data)
+            amount_dict[user.id].append(payment_record.amount)
+
+        records = []
+        for user_id, data_list in records_dict.items():
+            amount = sum(amount_dict[user_id])
+            user = users_dict[user_id]
+            record = TimeTrackingRecord(
+                user=user,
+                data=data_list,
+                total_amount=amount
+            )
+            records.append(
+                record
+            )
+        return GetTimeTrackingRecordsResponse(
+            records=records
+        )
+
+    async def update_record(self,
+                            user: User,
+                            request: UpdateTimeTrackingRecordRequest
+                            ) -> UpdateTimeTrackingRecordResponse:
+        try:
+            record_user = await UserService(self.session).get_by_id(user_id=request.user_id)
+            if not record_user:
+                return UpdateTimeTrackingRecordResponse(ok=False, message="Указанный пользователь не найден!")
+            if not record_user.pay_rate:
+                return UpdateTimeTrackingRecordResponse(ok=False, message="У пользователя не указана схема оплаты!")
+            existing_record_stmt = (
+                select(
+                    PaymentRecord
+                )
+                .where(
+                    PaymentRecord.user_id == request.user_id,
+                    PaymentRecord.start_date == request.date,
+                    PaymentRecord.end_date == request.date,
+                )
+            )
+            amount = (
+                PayrollService(
+                    self.session
+                )
+                .get_amount(
+                    user=record_user,
+                    work_units=request.hours
+                )
+            )
+            existing_record = await self.session.scalar(existing_record_stmt)
+            if existing_record:
+                existing_record: PaymentRecord
+                existing_record.work_units = request.hours
+                existing_record.amount = amount
+            else:
+                new_record = PaymentRecord(
+                    user_id=request.user_id,
+                    created_by_user_id=user.id,
+                    start_date=request.date,
+                    end_date=request.date,
+                    created_at=datetime.datetime.now(),
+                    payroll_scheme_key=record_user.pay_rate.payroll_scheme_key,
+                    amount=amount,
+                    work_units=request.hours
+                )
+                self.session.add(new_record)
+            await self.session.commit()
+            return UpdateTimeTrackingRecordResponse(ok=True, message="Запись успешно обновлена")
+        except Exception as e:
+            return UpdateTimeTrackingRecordResponse(ok=False, message=str(e))