nsj-rest-lib2 0.0.32__tar.gz → 0.0.34__tar.gz

{nsj_rest_lib2-0.0.32 → nsj_rest_lib2-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.32
+Version: 0.0.34
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas
@@ -12,7 +12,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.4
 Description-Content-Type: text/markdown
-Requires-Dist: nsj-rest-lib<6.0.0,>=5.1.3
+Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
 Requires-Dist: redis<7.0.0,>=6.4.0
 Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
 Requires-Dist: pydantic<3.0.0,>=2.11.9

{nsj_rest_lib2-0.0.32 → nsj_rest_lib2-0.0.34}/nsj_rest_lib2/compiler/compiler.py

@@ -33,6 +33,7 @@ from nsj_rest_lib2.compiler.util.relation_ref import RelationRefParser
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
+from nsj_rest_lib2.dto.escopo_dto import EscopoDTO
 
 
 class EDLCompiler:
@@ -44,13 +45,24 @@ class EDLCompiler:
         self._function_get_delete_compiler = FunctionGetDeleteCompiler()
 
     def compile_models(
-        self, entity_models: dict[str, EntityModel]
+        self,
+        entity_models: dict[str, EntityModel],
+        escopos: dict[str, EscopoDTO],
     ) -> list[CompilerResult]:
 
         compiler_results = []
         for entity_model_id in entity_models:
             entity_model = entity_models[entity_model_id]
-            compiler_result = self._compile_model(entity_model, entity_models)
+            escopo_dto = escopos.get(entity_model.escopo)
+            if escopo_dto is None:
+                raise Exception(
+                    f"EscopoDTO não informado para o escopo: {entity_model.escopo}."
+                )
+            compiler_result = self._compile_model(
+                entity_model,
+                entity_models,
+                escopo=escopo_dto,
+            )
             if compiler_result:
                 compiler_results.append(compiler_result)
 
@@ -60,6 +72,7 @@ class EDLCompiler:
         self,
         edl_json: dict[str, Any],
         dependencies_edls: list[dict[str, Any]],
+        escopo: EscopoDTO,
     ) -> CompilerResult | None:
         entity_model = EntityModel(**edl_json)
 
@@ -71,35 +84,36 @@ class EDLCompiler:
                 dependency_entity_model = EntityModel(**dependency_edl)
             entity_models.append(dependency_entity_model)
 
-        return self.compile_model(entity_model, entity_models)
+        return self.compile_model(entity_model, entity_models, escopo=escopo)
 
     def compile_model(
         self,
         entity_model: EntityModelBase,
         dependencies_models: list[tuple[str, EntityModelBase]],
+        escopo: EscopoDTO,
     ) -> CompilerResult | None:
         entity_models = {}
         for dependency_entity_model in dependencies_models:
             complete_entity_id = dependency_entity_model[0]
             entity_models[complete_entity_id] = dependency_entity_model[1]
 
-        return self._compile_model(entity_model, entity_models)
+        return self._compile_model(entity_model, entity_models, escopo=escopo)
 
     def _compile_model(
         self,
         entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
-        escopo: str | None = None,
+        escopo: EscopoDTO | None,
         prefx_class_name: str = "",
     ) -> CompilerResult | None:
         if entity_model.mixin:
             return None
 
-        if escopo is None and (isinstance(entity_model, EntityModel)):
-            escopo = entity_model.escopo
-
-        if not escopo:
-            raise Exception(f"Escopo não definido para a entidade: {entity_model.id}.")
+        if escopo is None:
+            raise Exception(
+                f"EscopoDTO não informado para a entidade: {getattr(entity_model, 'id', '<unknown>')}."
+            )
+        escopo_codigo = escopo.codigo
 
         # Tratando dos dados base para a extensão parcial
         partial_metadata: dict[str, str] | None = None
@@ -250,7 +264,7 @@ class EDLCompiler:
         ) = self._properties_compiler.compile(
             properties_structure,
             map_unique_by_property,
-            escopo,
+            escopo_codigo,
             entity_model,
             entity_models,
             prefx_class_name,
@@ -371,9 +385,7 @@ class EDLCompiler:
         compiler_result.list_function_type_class_name = list_function_type_class
         compiler_result.delete_function_type_class_name = delete_function_type_class
         compiler_result.source_get_function_type = get_function_code.strip() or None
-        compiler_result.source_list_function_type = (
-            list_function_code.strip() or None
-        )
+        compiler_result.source_list_function_type = list_function_code.strip() or None
         compiler_result.source_delete_function_type = (
             delete_function_code.strip() or None
         )
@@ -392,6 +404,7 @@ class EDLCompiler:
             compiler_result.api_expose = entity_model.api.expose
             compiler_result.api_resource = entity_model.api.resource
             compiler_result.api_verbs = entity_model.api.verbs
+        compiler_result.service_account = escopo.service_account
 
         get_logger().debug(f"código gerado para a entidade: {entity_model.id}")
         get_logger().debug("DTO Code:")
@@ -848,7 +861,14 @@ if __name__ == "__main__":
         entities[complete_entity_id] = entity_model
 
     compiler = EDLCompiler()
-    compiler_results = compiler.compile_models(entities)
+    escopos = {}
+    for entity_model in entities.values():
+        if entity_model.escopo not in escopos:
+            escopos[entity_model.escopo] = EscopoDTO(
+                codigo=entity_model.escopo,
+                service_account=None,
+            )
+    compiler_results = compiler.compile_models(entities, escopos)
 
     with open("output_compilacao_local.py", "w") as f:
         for compiler_result in compiler_results:

{nsj_rest_lib2-0.0.32 → nsj_rest_lib2-0.0.34}/nsj_rest_lib2/compiler/model.py

@@ -42,6 +42,7 @@ class CompilerResult:
         self.api_expose: bool | None = None
         self.api_resource: str | None = None
         self.api_verbs: list[str] | None = None
+        self.service_account: str | None = None
         self.relations_dependencies: list[RelationDependency] | None = None
         self.insert_function_class_name: str | None = None
         self.insert_function_name: str | None = None

nsj_rest_lib2-0.0.34/nsj_rest_lib2/controller/dynamic_controller.py

@@ -0,0 +1,413 @@
+import json
+
+from typing import Any, Callable
+
+from flask import Flask, request
+
+from nsj_rest_lib.settings import APP_NAME
+
+from nsj_gcf_utils.rest_error_util import format_json_error
+
+from nsj_multi_database_lib.decorator.multi_database import multi_database
+
+from nsj_rest_lib.controller.controller_util import DEFAULT_RESP_HEADERS
+from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.get_route import GetRoute
+from nsj_rest_lib.controller.post_route import PostRoute
+from nsj_rest_lib.controller.put_route import PutRoute
+from nsj_rest_lib.controller.patch_route import PatchRoute
+from nsj_rest_lib.controller.delete_route import DeleteRoute
+
+from nsj_rest_lib2.exception import MissingEntityConfigException
+from nsj_rest_lib2.service.entity_loader import EntityLoader
+
+
+def _get_query_args() -> tuple[str, str, bool]:
+    # Tentando ler do query args
+    query_args = request.args
+    tenant = query_args.get("tenant")
+    grupo_empresarial = query_args.get("grupo_empresarial")
+    force_reload = query_args.get("force_reload", "false").lower() == "true"
+
+    # Tentando ler do corpo da requisição
+    try:
+        body_str = request.data.decode("utf-8")
+        body_json = json.loads(body_str)
+
+        if not tenant:
+            tenant = body_json.get("tenant")
+        if not grupo_empresarial:
+            grupo_empresarial = body_json.get("grupo_empresarial")
+    except:
+        pass
+
+    return (str(tenant), str(grupo_empresarial), force_reload)
+
+
+def _endpoint_name(func: Any, multidb: bool, root: str) -> str:
+    suffix = "_mb" if multidb else ""
+    return f"{root}_{func.__name__}{suffix}"
+
+
+def setup_dynamic_routes(
+    flask_app: Flask,
+    multidb: bool = True,
+    dynamic_root_path: str = "edl1",
+    injector_factory: Any = None,
+    escopo_in_url: bool = False,
+) -> None:
+
+    if not escopo_in_url:
+        COLLECTION_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_resource>"
+        ONE_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_resource>/<id>"
+    else:
+        COLLECTION_DYNAMIC_ROUTE = (
+            f"/{APP_NAME}/{dynamic_root_path}/<entity_escopo>/<entity_resource>"
+        )
+        ONE_DYNAMIC_ROUTE = (
+            f"/{APP_NAME}/{dynamic_root_path}/<entity_escopo>/<entity_resource>/<id>"
+        )
+
+    def _dynamic_route_wrapper(
+        route_builder: Callable[[tuple[Any, ...]], Callable[..., Any]],
+        endpoint_suffix: str | None = None,
+    ) -> Callable[..., Any]:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if "entity_resource" not in kwargs:
+                msg = "Faltando parâmetro identificador da entidade na URL."
+                return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+            entity_resource = kwargs.pop("entity_resource")
+
+            entity_escopo = kwargs.pop("entity_escopo", "")
+
+            tenant, grupo_empresarial, force_reload = _get_query_args()
+
+            try:
+                entity_loader = EntityLoader()
+                entity_config = entity_loader.load_entity_source(
+                    entity_resource,
+                    tenant,
+                    grupo_empresarial,
+                    escopo=entity_escopo,
+                    force_reload=force_reload,
+                )
+            except MissingEntityConfigException:
+                msg = f"Entity configuration for {entity_resource} not found."
+                return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+            (
+                _,
+                _,
+                _,
+                _,
+                _,
+                service_account,
+                *rest,
+            ) = entity_config
+
+            route_handler = route_builder(entity_config)
+
+            if multidb:
+                route_handler = multi_database(service_account)(route_handler)
+
+            return route_handler(*args, **kwargs)
+
+        wrapper.__name__ = endpoint_suffix or f"{route_builder.__name__}_wrapper"
+        return wrapper
+
+    def list_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            _insert_function_class_name,
+            _update_function_class_name,
+            _insert_function_name,
+            _update_function_name,
+            _get_function_name,
+            list_function_name,
+            _delete_function_name,
+            _get_function_type_class_name,
+            list_function_type_class_name,
+            _delete_function_type_class_name,
+        ) = entity_config
+
+        def list_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "GET" not in api_verbs:
+                return ("", 405, {})
+
+            route = ListRoute(
+                url=COLLECTION_DYNAMIC_ROUTE,
+                http_method="GET",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+                list_function_name=list_function_name,
+                list_function_type_class=etities_dict.get(
+                    list_function_type_class_name
+                ),
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return list_dynamic
+
+    def get_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            _insert_function_class_name,
+            _update_function_class_name,
+            _insert_function_name,
+            _update_function_name,
+            get_function_name,
+            _list_function_name,
+            _delete_function_name,
+            get_function_type_class_name,
+            _list_function_type_class_name,
+            _delete_function_type_class_name,
+        ) = entity_config
+
+        def get_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "GET" not in api_verbs:
+                return ("", 405, {})
+
+            route = GetRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="GET",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+                get_function_name=get_function_name,
+                get_function_type_class=etities_dict.get(get_function_type_class_name),
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return get_dynamic
+
+    def post_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            insert_function_class_name,
+            _update_function_class_name,
+            insert_function_name,
+            _update_function_name,
+            _get_function_name,
+            _list_function_name,
+            _delete_function_name,
+            _get_function_type_class_name,
+            _list_function_type_class_name,
+            _delete_function_type_class_name,
+        ) = entity_config
+
+        def post_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "POST" not in api_verbs:
+                return ("", 405, {})
+
+            insert_function_type_class = (
+                etities_dict.get(insert_function_class_name)
+                if insert_function_class_name
+                else None
+            )
+
+            route = PostRoute(
+                url=COLLECTION_DYNAMIC_ROUTE,
+                http_method="POST",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+                insert_function_type_class=insert_function_type_class,
+                insert_function_name=insert_function_name,
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return post_dynamic
+
+    def put_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            _insert_function_class_name,
+            update_function_class_name,
+            _insert_function_name,
+            update_function_name,
+            _get_function_name,
+            _list_function_name,
+            _delete_function_name,
+            _get_function_type_class_name,
+            _list_function_type_class_name,
+            _delete_function_type_class_name,
+        ) = entity_config
+
+        def put_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "PUT" not in api_verbs:
+                return ("", 405, {})
+
+            update_function_type_class = (
+                etities_dict.get(update_function_class_name)
+                if update_function_class_name
+                else None
+            )
+
+            route = PutRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="PUT",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+                update_function_type_class=update_function_type_class,
+                update_function_name=update_function_name,
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return put_dynamic
+
+    def patch_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            _insert_function_class_name,
+            _update_function_class_name,
+            _insert_function_name,
+            _update_function_name,
+            _get_function_name,
+            _list_function_name,
+            _delete_function_name,
+            *_,
+        ) = entity_config
+
+        def patch_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "PATCH" not in api_verbs:
+                return ("", 405, {})
+
+            route = PatchRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="PATCH",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return patch_dynamic
+
+    def delete_dynamic_builder(entity_config: tuple[Any, ...]) -> Callable[..., Any]:
+        (
+            dto_class_name,
+            entity_class_name,
+            etities_dict,
+            api_expose,
+            api_verbs,
+            _service_account,
+            _insert_function_class_name,
+            _update_function_class_name,
+            _insert_function_name,
+            _update_function_name,
+            _get_function_name,
+            _list_function_name,
+            delete_function_name,
+            _get_function_type_class_name,
+            _list_function_type_class_name,
+            delete_function_type_class_name,
+        ) = entity_config
+
+        def delete_dynamic(*args: Any, **kwargs: Any) -> Any:
+            if not api_expose or "DELETE" not in api_verbs:
+                return ("", 405, {})
+
+            route = DeleteRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="DELETE",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+                injector_factory=injector_factory,
+                delete_function_name=delete_function_name,
+                delete_function_type_class=etities_dict.get(
+                    delete_function_type_class_name
+                ),
+            )
+
+            return route.handle_request(*args, **kwargs)
+
+        return delete_dynamic
+
+    list_dynamic = _dynamic_route_wrapper(
+        list_dynamic_builder, endpoint_suffix="list_dynamic"
+    )
+    get_dynamic = _dynamic_route_wrapper(
+        get_dynamic_builder, endpoint_suffix="get_dynamic"
+    )
+    post_dynamic = _dynamic_route_wrapper(
+        post_dynamic_builder, endpoint_suffix="post_dynamic"
+    )
+    put_dynamic = _dynamic_route_wrapper(
+        put_dynamic_builder, endpoint_suffix="put_dynamic"
+    )
+    patch_dynamic = _dynamic_route_wrapper(
+        patch_dynamic_builder, endpoint_suffix="patch_dynamic"
+    )
+    delete_dynamic = _dynamic_route_wrapper(
+        delete_dynamic_builder, endpoint_suffix="delete_dynamic"
+    )
+
+    # Registrando as rotas no flask
+    flask_app.add_url_rule(
+        COLLECTION_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(list_dynamic, multidb, dynamic_root_path),
+        view_func=list_dynamic,
+        methods=["GET"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(get_dynamic, multidb, dynamic_root_path),
+        view_func=get_dynamic,
+        methods=["GET"],
+    )
+    flask_app.add_url_rule(
+        COLLECTION_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(post_dynamic, multidb, dynamic_root_path),
+        view_func=post_dynamic,
+        methods=["POST"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(put_dynamic, multidb, dynamic_root_path),
+        view_func=put_dynamic,
+        methods=["PUT"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(patch_dynamic, multidb, dynamic_root_path),
+        view_func=patch_dynamic,
+        methods=["PATCH"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(delete_dynamic, multidb, dynamic_root_path),
+        view_func=delete_dynamic,
+        methods=["DELETE"],
+    )

nsj_rest_lib2-0.0.34/nsj_rest_lib2/dto/__init__.py

@@ -0,0 +1 @@
+#

nsj_rest_lib2-0.0.34/nsj_rest_lib2/dto/escopo_dto.py

@@ -0,0 +1,39 @@
+import uuid
+
+from nsj_rest_lib.decorator.dto import DTO
+from nsj_rest_lib.descriptor.dto_field import DTOField
+from nsj_rest_lib.descriptor.dto_field_validators import DTOFieldValidators
+from nsj_rest_lib.dto.dto_base import DTOBase
+
+
+@DTO()
+class EscopoDTO(DTOBase):
+
+    id: uuid.UUID = DTOField(
+        pk=True,
+        resume=True,
+        not_null=True,
+        default_value=uuid.uuid4,
+        strip=True,
+        min=36,
+        max=36,
+        validator=DTOFieldValidators().validate_uuid,
+    )
+
+    codigo: str = DTOField(
+        resume=True,
+        not_null=True,
+        strip=True,
+        min=1,
+        max=100,
+        unique="escopo_codigo",
+        candidate_key=True,
+    )
+
+    service_account: str = DTOField(
+        resume=True,
+        strip=True,
+        min=5,
+        max=320,
+        validator=DTOFieldValidators().validate_email,
+    )

nsj_rest_lib2-0.0.34/nsj_rest_lib2/entity/escopo_entity.py

@@ -0,0 +1,15 @@
+import uuid
+
+from nsj_rest_lib.entity.entity_base import EntityBase
+from nsj_rest_lib.decorator.entity import Entity
+
+
+@Entity(
+    table_name="restlib2.escopo",
+    pk_field="id",
+    default_order_fields=["codigo", "id"],
+)
+class EscopoEntity(EntityBase):
+    id: uuid.UUID = None
+    codigo: str = None
+    service_account: str = None

{nsj_rest_lib2-0.0.32 → nsj_rest_lib2-0.0.34}/nsj_rest_lib2/service/entity_config_writer.py

@@ -70,6 +70,7 @@ class EntityConfigWriter:
         return {
             "dto_class_name": compiler_result.dto_class_name,
             "entity_class_name": compiler_result.entity_class_name,
+            "service_account": compiler_result.service_account,
             "insert_function_class_name": compiler_result.insert_function_class_name,
             "insert_function_name": compiler_result.insert_function_name,
             "source_insert_function": compiler_result.source_insert_function,
@@ -141,6 +142,7 @@ class EntityConfigWriter:
             compiler_result.source_get_function_type,
             compiler_result.source_list_function_type,
             compiler_result.source_delete_function_type,
+            compiler_result.service_account,
         ):
             hasher.update(content)