update unit test for new version

Author: LuisLuii

.gitignore

@@ -4,3 +4,4 @@ tests/htmlcov
 /poetry.lock
 /pyproject.toml
 *.pyc
+workspace.xml

src/fastapi_quickcrud/crud_router.py

@@ -40,6 +40,7 @@ def crud_router_builder(
         dependencies: Optional[List[callable]] = None,
         crud_models: Optional[CRUDModel] = None,
         async_mode: Optional[bool] = None,
+        foreign_include: Optional[any] = None,
         sql_type: Optional[SqlType] = None,
         **router_kwargs: Any) -> APIRouter:
     """
@@ -146,7 +147,11 @@ async def async_runner(f):
                                                      sql_type=sql_type,
                                                      exclude_primary_key=NO_PRIMARY_KEY)
 
-    crud_service = query_service(model=db_model, async_mode=async_mode)
+    foreign_table_mapping = {db_model.__tablename__: db_model}
+    if foreign_include:
+        for i in foreign_include:
+            foreign_table_mapping[i.__tablename__] = i
+    crud_service = query_service(model=db_model, async_mode=async_mode, foreign_table_mapping=foreign_table_mapping)
     # else:
     #     crud_service = SQLAlchemyPostgreQueryService(model=db_model, async_mode=async_mode)
 

src/fastapi_quickcrud/misc/abstract_query.py

@@ -8,13 +8,13 @@
 
 from .exceptions import UnknownOrderType, UnknownColumn, UpdateColumnEmptyException
 from .type import Ordering
-from .utils import clean_input_fields
+from .utils import clean_input_fields, path_query_builder
 from .utils import find_query_builder
 
 
 class SQLAlchemyGeneralSQLQueryService(ABC):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
 
         """
         :param model: declarative_base model
@@ -24,24 +24,32 @@ def __init__(self, *, model, async_mode):
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
+        self.foreign_table_mapping = foreign_table_mapping
 
     def get_many(self, *,
                  join_mode,
                  query,
+                 target_model=None,
+                 abstract_param=None
                  ) -> BinaryExpression:
         filter_args = query
         limit = filter_args.pop('limit', None)
         offset = filter_args.pop('offset', None)
         order_by_columns = filter_args.pop('order_by_columns', None)
+        model = self.model
+        if target_model:
+            model = self.foreign_table_mapping[target_model]
         filter_list: List[BinaryExpression] = find_query_builder(param=filter_args,
-                                                                 model=self.model_columns)
+                                                                 model=model)
+        path_filter_list: List[BinaryExpression] = path_query_builder(params=abstract_param,
+                                                                      model=self.foreign_table_mapping)
         join_table_instance_list: list = self.get_join_select_fields(join_mode)
 
-        model = self.model
+
         if not isinstance(self.model, Table):
             model = model.__table__
 
-        stmt = select(*[model] + join_table_instance_list).filter(and_(*filter_list))
+        stmt = select(*[model] + join_table_instance_list).filter(and_(*filter_list+path_filter_list))
         if order_by_columns:
             order_by_query_list = []
 
@@ -79,7 +87,6 @@ def get_one(self, *,
         model = self.model
         if not isinstance(self.model, Table):
             model = model.__table__
-        a = model.c._all_columns
         stmt = select(*[model] + join_table_instance_list).where(and_(*filter_list + extra_query_expression))
         # stmt = session.query(*[model] + join_table_instance_list).filter(and_(*filter_list + extra_query_expression))
         stmt = self.get_join_by_excpression(stmt, join_mode=join_mode)
@@ -130,9 +137,9 @@ def get_join_select_fields(self, join_mode=None):
                 if 'exclude' in local_reference and local_reference['exclude']:
                     continue
                 for column in local_reference['reference_table_columns']:
-                    foreign_name = local_reference['local']['local_column']
+                    foreign_table_name = local_reference['reference']['reference_table']
                     join_table_instance_list.append(
-                        column.label(foreign_name + '_foreign_____' + str(column).split('.')[1]))
+                        column.label(foreign_table_name + '_foreign_____' + str(column).split('.')[1]))
         return join_table_instance_list
 
     def get_join_by_excpression(self, stmt: BinaryExpression, join_mode=None) -> BinaryExpression:
@@ -202,15 +209,16 @@ def model_query(self,
 
 class SQLAlchemyPGSQLQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
 
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super(SQLAlchemyPGSQLQueryService,
               self).__init__(model=model,
-                             async_mode=async_mode)
+                             async_mode=async_mode,
+                             foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -255,13 +263,14 @@ def upsert(self, *,
 
 class SQLAlchemySQLITEQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -276,13 +285,14 @@ def upsert(self, *,
 
 class SQLAlchemyMySQLQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -297,13 +307,14 @@ def upsert(self, *,
 
 class SQLAlchemyMariaDBQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -318,13 +329,14 @@ def upsert(self, *,
 
 class SQLAlchemyOracleQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -339,13 +351,14 @@ def upsert(self, *,
 
 class SQLAlchemyMSSqlQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode
@@ -360,13 +373,14 @@ def upsert(self, *,
 
 class SQLAlchemyNotSupportQueryService(SQLAlchemyGeneralSQLQueryService):
 
-    def __init__(self, *, model, async_mode):
+    def __init__(self, *, model, async_mode, foreign_table_mapping):
         """
         :param model: declarative_base model
         :param async_mode: bool
         """
         super().__init__(model=model,
-                         async_mode=async_mode)
+                         async_mode=async_mode,
+                         foreign_table_mapping=foreign_table_mapping)
         self.model = model
         self.model_columns = model
         self.async_mode = async_mode