feat(all): 同步最新进度

core/db/crud.py

@@ -21,20 +21,24 @@ class CRUD:
         self.session = session
         self.model = model
 
-    async def get(self, filters: dict) -> Optional[Model]:
+    async def get(self, filters: dict, model: Model = None) -> Optional[Model]:
+        model = model or self.model
         async with self.session.begin():
-            result = await self.session.execute(select(self.model).filter(
-                *self.build_filter_conditions(filters))
+            result = await self.session.execute(select(model).filter(
+                *self.build_filter_conditions(filters, model))
             )
             record = result.scalar_one_or_none()
         return record
 
-    async def get_paginated(self, filters: dict, page: int = 1, page_size: int = 10) -> Tuple[List[Model], int]:
+    async def get_paginated(
+            self, filters: dict, page: int = 1, page_size: int = 10, model: Model = None
+    ) -> Tuple[List[Model], int]:
+        model = model or self.model
         async with self.session.begin():
             filter_conditions = self.build_filter_conditions(filters) if filters else []
-            query = select(self.model).filter(*filter_conditions).order_by(desc(self.model.created_at))
+            query = select(model).filter(*filter_conditions).order_by(desc(model.created_at))
 
-            total_query = select(func.count()).select_from(self.model).filter(*filter_conditions)
+            total_query = select(func.count()).select_from(model).filter(*filter_conditions)
             total_result = await self.session.execute(total_query)
             total = total_result.scalar()
 
@@ -44,9 +48,12 @@ class CRUD:
 
         return records, total
 
-    async def get_grouped_count(self, group_by_field: str, filters: Dict[str, Any] = None) -> Dict[Any, int]:
+    async def get_grouped_count(
+            self, group_by_field: str, filters: Dict[str, Any] = None, model: Model = None
+    ) -> Dict[Any, int]:
+        model = model or self.model
         filter_conditions = self.build_filter_conditions(filters) if filters else []
-        group_by = getattr(self.model, group_by_field)
+        group_by = getattr(model, group_by_field)
         query = select(group_by, func.count()).filter(*filter_conditions).group_by(group_by)
 
         async with self.session.begin():
@@ -55,32 +62,35 @@ class CRUD:
 
         return {record[0]: record[1] for record in records}
 
-    async def create(self, data: dict, filters: dict) -> Union[Model, bool]:
+    async def create(self, data: dict, filters: dict, model: Model = None) -> Union[Model, bool]:
+        model = model or self.model
         async with self.session.begin():
-            result = await self.session.execute(select(self.model).filter(
-                *self.build_filter_conditions(filters))
+            result = await self.session.execute(select(model).filter(
+                *self.build_filter_conditions(filters, model))
             )
             if result.scalars().first() is not None:
                 return False
 
-            record = self.model(**data)
+            record = model(**data)
             self.session.add(record)
             await self.session.commit()
         return record
 
-    async def get_all(self, filters: dict = None) -> List[Model]:
+    async def get_all(self, filters: dict = None, model: Model = None) -> List[Model]:
+        model = model or self.model
         async with self.session.begin():
             result = await self.session.execute(
-                select(self.model) if filters is None else select(self.model).filter(
-                    *self.build_filter_conditions(filters)).order_by(desc(self.model.insert_time))
+                select(model) if filters is None else select(model).filter(
+                    *self.build_filter_conditions(filters, model)).order_by(desc(model.insert_time))
             )
             records = result.scalars().all()
         return records
 
-    async def update(self, data: dict, filters: dict) -> Optional[Model]:
+    async def update(self, data: dict, filters: dict, model: Model = None) -> Optional[Model]:
+        model = model or self.model
         async with self.session.begin():
-            result = await self.session.execute(select(self.model).filter(
-                *self.build_filter_conditions(filters))
+            result = await self.session.execute(select(model).filter(
+                *self.build_filter_conditions(filters, model))
             )
             record = result.scalars().first()
 
@@ -101,10 +111,11 @@ class CRUD:
                 await self.session.commit()
         return record
 
-    async def updates(self, data: dict, filters: dict) -> Optional[Model]:
+    async def updates(self, data: dict, filters: dict, model: Model = None) -> Optional[Model]:
+        model = model or self.model
         async with self.session.begin():
-            result = await self.session.execute(select(self.model).filter(
-                *self.build_filter_conditions(filters))
+            result = await self.session.execute(select(model).filter(
+                *self.build_filter_conditions(filters, model))
             )
             records = result.scalars().all()
 
@@ -125,10 +136,11 @@ class CRUD:
                 await self.session.commit()
         return records
 
-    async def delete(self, filters: dict) -> bool:
+    async def delete(self, filters: dict, model: Model = None) -> bool:
+        model = model or self.model
         async with self.session.begin():
-            result = await self.session.execute(select(self.model).filter(
-                *self.build_filter_conditions(filters))
+            result = await self.session.execute(select(model).filter(
+                *self.build_filter_conditions(filters, model))
             )
             record = result.scalars().first()
 
@@ -139,7 +151,7 @@ class CRUD:
             await self.session.commit()
         return True
 
-    def build_filter_conditions(self, filters: Dict[str, Any]) -> tuple:
+    def build_filter_conditions(self, filters: Dict[str, Any], model: Model) -> tuple:
         conditions = []
 
         for key, value in filters.items():
@@ -158,7 +170,7 @@ class CRUD:
             else:
                 field_name = key
 
-            field = getattr(self.model, field_name)
+            field = getattr(model, field_name)
 
             if operator == 'like':  # 模糊匹配
                 conditions.append(field.like(f'%{value}%'))