Merge pull request #16 from LuisLuii/feature/foreign_tree

Feature/foreign tree

Author: LuisLuii

.gitignore

@@ -5,5 +5,7 @@ tests/htmlcov
 /pyproject.toml
 *.xml
 *.pyc
+workspace.xml
 *.iml
+*.xml
 *.sh

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:
     """
@@ -108,18 +109,19 @@ def get_transaction_session():
 
     if async_mode is None:
         async_mode = inspect.isasyncgen(db_session())
-    
+
     if sql_type is None:
         async def async_runner(f):
             return [i.bind.name async for i in f()]
+
         try:
             if async_mode:
                 sql_type, = asyncio.get_event_loop().run_until_complete(async_runner(db_session))
             else:
                 sql_type, = [i.bind.name for i in db_session()]
         except Exception:
             raise RuntimeError("Some unknown problem occurred error, maybe you are uvicorn.run with reload=True. "
-                                "Try declaring sql_type for crud_router_builder yourself using from fastapi_quickcrud.misc.type import SqlType")
+                               "Try declaring sql_type for crud_router_builder yourself using from fastapi_quickcrud.misc.type import SqlType")
 
     if not crud_methods and NO_PRIMARY_KEY == False:
         crud_methods = CrudMethods.get_declarative_model_full_crud_method()
@@ -144,9 +146,15 @@ async def async_runner(f):
                                                      crud_methods=crud_methods,
                                                      exclude_columns=exclude_columns,
                                                      sql_type=sql_type,
+                                                     foreign_include=foreign_include,
                                                      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:
+            model , _= convert_table_to_model(i)
+            foreign_table_mapping[model.__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)
 
@@ -372,6 +380,48 @@ def put_many_api(request_response_model: dict, dependencies):
                                async_mode=async_mode,
                                response_model=_response_model)
 
+    def find_one_foreign_tree_api(request_response_model: dict, dependencies):
+        _foreign_list_model = request_response_model.get('foreignListModel', None)
+        for i in _foreign_list_model:
+            _request_query_model = i["request_query_model"]
+            _response_model = i["response_model"]
+            _path = i["path"]
+            _function_name = i["function_name"]
+            request_url_param_model = i["primary_key_dataclass_model"]
+            routes_source.find_one_foreign_tree(path=_path,
+                                                request_query_model=_request_query_model,
+                                                response_model=_response_model,
+                                                request_url_param_model=request_url_param_model,
+                                                db_session=db_session,
+                                                query_service=crud_service,
+                                                parsing_service=result_parser,
+                                                execute_service=execute_service,
+                                                dependencies=dependencies,
+                                                api=api,
+                                                function_name=_function_name,
+                                                async_mode=async_mode)
+
+    def find_many_foreign_tree_api(request_response_model: dict, dependencies):
+        _foreign_list_model = request_response_model.get('foreignListModel', None)
+        for i in _foreign_list_model:
+            _request_query_model = i["request_query_model"]
+            _response_model = i["response_model"]
+            _path = i["path"]
+            _function_name = i["function_name"]
+            request_url_param_model = i["primary_key_dataclass_model"]
+            routes_source.find_many_foreign_tree(path=_path,
+                                                 request_query_model=_request_query_model,
+                                                 response_model=_response_model,
+                                                 request_url_param_model=request_url_param_model,
+                                                 db_session=db_session,
+                                                 query_service=crud_service,
+                                                 parsing_service=result_parser,
+                                                 execute_service=execute_service,
+                                                 dependencies=dependencies,
+                                                 api=api,
+                                                 async_mode=async_mode,
+                                                 function_name=_function_name)
+
     api_register = {
         CrudMethods.FIND_ONE.value: find_one_api,
         CrudMethods.FIND_MANY.value: find_many_api,
@@ -385,7 +435,9 @@ def put_many_api(request_response_model: dict, dependencies):
         CrudMethods.PATCH_ONE.value: patch_one_api,
         CrudMethods.PATCH_MANY.value: patch_many_api,
         CrudMethods.UPDATE_ONE.value: put_one_api,
-        CrudMethods.UPDATE_MANY.value: put_many_api
+        CrudMethods.UPDATE_MANY.value: put_many_api,
+        CrudMethods.FIND_ONE_WITH_FOREIGN_TREE.value: find_one_foreign_tree_api,
+        CrudMethods.FIND_MANY_WITH_FOREIGN_TREE.value: find_many_foreign_tree_api
     }
     api = APIRouter(**router_kwargs)
 

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:
@@ -182,6 +189,28 @@ def model_query(self,
         stmt = select(self.model).where(and_(*filter_list))
         return stmt
 
+    def get_one_with_foreign_pk(self, *,
+                                 join_mode,
+                                 query,
+                                 target_model,
+                                 abstract_param=None
+                                 ) -> BinaryExpression:
+        model = self.foreign_table_mapping[target_model]
+        filter_list: List[BinaryExpression] = find_query_builder(param=query,
+                                                                 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)
+
+        if not isinstance(self.model, Table):
+            model = model.__table__
+
+        stmt = select(*[model] + join_table_instance_list).filter(and_(*filter_list + path_filter_list))
+
+        stmt = self.get_join_by_excpression(stmt, join_mode=join_mode)
+        return stmt
+
+
     # def update(self, *,
     #            update_args,
     #            extra_query,
@@ -202,15 +231,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 +285,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 +307,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 +329,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 +351,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 +373,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 +395,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