nsj-rest-lib2 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -105,6 +105,7 @@ class EDLCompiler:
             enum_classes,
             related_imports,
             relations_dependencies,
+            fixed_filters,
         ) = self._properties_compiler.compile(
             properties_structure,
             map_unique_by_property,
@@ -114,7 +115,11 @@ class EDLCompiler:
 
         # Gerando o código do DTO
         dto_class_name, code_dto = self._dto_compiler.compile(
-            entity_model, ast_dto_attributes, enum_classes, related_imports
+            entity_model,
+            ast_dto_attributes,
+            enum_classes,
+            related_imports,
+            fixed_filters,
         )
 
         # Gerando o código da Entity

nsj_rest_lib2/compiler/dto_compiler.py

@@ -3,6 +3,7 @@ import ast
 import black
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 from nsj_rest_lib2.compiler.util.type_naming_util import compile_dto_class_name
 
@@ -17,6 +18,7 @@ class DTOCompiler:
         ast_dto_attributes: list[ast.stmt],
         enum_classes: list[ast.stmt],
         related_imports: list[tuple[str, str, str]],
+        fixed_filters: list[tuple[str, BasicTypes]],
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -71,6 +73,18 @@ class DTOCompiler:
                 names=[ast.alias(name="DTOBase", asname=None)],
                 level=0,
             ),
+            # from nsj_rest_lib.descriptor.dto_left_join_field import EntityRelationOwner
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_left_join_field",
+                names=[ast.alias(name="EntityRelationOwner", asname=None)],
+                level=0,
+            ),
+            # from nsj_rest_lib.descriptor.dto_object_field import DTOObjectField
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_object_field",
+                names=[ast.alias(name="DTOObjectField", asname=None)],
+                level=0,
+            ),
         ]
 
         for import_ in related_imports:
@@ -89,6 +103,19 @@ class DTOCompiler:
                 )
             )
 
+        # Keywords para tipos usados em fixed_filters
+        keywords_decorator_dto = []
+        for fixed_filter in fixed_filters:
+            keywords_decorator_dto.append(
+                ast.keyword(
+                    arg="fixed_filters",
+                    value=ast.Dict(
+                        keys=[ast.Constant(value=fixed_filter[0])],
+                        values=[ast.Constant(value=fixed_filter[1])],
+                    ),
+                )
+            )
+
         # Criando o ast da classe
         class_name = compile_dto_class_name(entity_model.id)
         ast_class = ast.ClassDef(
@@ -99,7 +126,7 @@ class DTOCompiler:
                 ast.Call(
                     func=ast.Name(id="DTO", ctx=ast.Load()),
                     args=[],
-                    keywords=[],
+                    keywords=keywords_decorator_dto,
                 )
             ],
             body=ast_dto_attributes,

nsj_rest_lib2/compiler/edl_model/column_meta_model.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field, model_validator
-from typing import List, Optional, Literal
+from typing import Optional
 
 
 class ColumnMetaModel(BaseModel):

nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py

@@ -1,6 +1,8 @@
+from typing import List, Optional
 from pydantic import BaseModel, Field
 
 from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes, PropertyType
+from nsj_rest_lib2.compiler.edl_model.property_meta_model import DomainConfigModel
 
 
 class TraitPropertyMetaModel(BaseModel):
@@ -8,3 +10,7 @@ class TraitPropertyMetaModel(BaseModel):
     value: BasicTypes = Field(
         ..., description="Valor fixo da propriedade de condicionamento do trait."
     )
+    domain_config: Optional[List[DomainConfigModel]] = Field(
+        None,
+        description="Lista de valores permitidos.",
+    )

nsj_rest_lib2/compiler/property_compiler.py

@@ -7,12 +7,16 @@ from nsj_rest_lib2.compiler.compiler_structures import (
 )
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 from nsj_rest_lib2.compiler.edl_model.primitives import (
+    BasicTypes,
     CardinalityTypes,
     PrimitiveTypes,
     REGEX_EXTERNAL_REF,
     REGEX_INTERNAL_REF,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
+    TraitPropertyMetaModel,
+)
 from nsj_rest_lib2.compiler.model import RelationDependency
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 from nsj_rest_lib2.compiler.util.type_naming_util import (
@@ -42,6 +46,7 @@ class EDLPropertyCompiler:
         list[ast.stmt],
         list[tuple[str, str, str]],
         list[RelationDependency],
+        list[tuple[str, BasicTypes]],
     ]:
 
         # TODO Criar opção de campo calculado?
@@ -73,6 +78,7 @@ class EDLPropertyCompiler:
         enum_classes = []
         related_imports = []
         relations_dependencies = []
+        fixed_filters = []
 
         if properties_structure.properties is None:
             return (ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes)
@@ -83,7 +89,7 @@ class EDLPropertyCompiler:
             # DTO
             ## Tratando propriedade simples (não array, não object)
             if isinstance(prop.type, PrimitiveTypes):
-                self.compile_simple_property(
+                self._compile_simple_property(
                     properties_structure,
                     map_unique_by_property,
                     entity_model,
@@ -97,127 +103,49 @@ class EDLPropertyCompiler:
 
             elif isinstance(prop.type, str):
                 external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
+                internal_match = re.match(REGEX_INTERNAL_REF, prop.type)
 
                 if external_match:
                     # Resolvendo o id da entidade
                     related_entity_id = external_match.group(2)
-
-                    # Resolvendo o nome das classes de DTO e Entity
-                    related_dto_class_name = compile_dto_class_name(related_entity_id)
-                    related_entity_class_name = compile_entity_class_name(
-                        related_entity_id
-                    )
-
-                    # Resolvendo o caminho do import
                     related_entity_key = external_match.group(0)
 
-                    related_entity = entity_models.get(related_entity_key)
-                    if not related_entity:
-                        raise Exception(
-                            f"Entidade '{entity_model.id}' possui uma referência externa para uma entidade inexistente: '{related_entity_key}', por meio da propriedade: '{pkey}'."
-                        )
-
-                    tenant = related_entity.tenant
-                    grupo_empresarial = related_entity.grupo_empresarial
-                    grupo_key, tenant_key, default_key = compile_namespace_keys(
-                        tenant, grupo_empresarial
+                    self._compile_external_relation(
+                        related_entity_id,
+                        related_entity_key,
+                        entity_model,
+                        entity_models,
+                        properties_structure,
+                        ast_dto_attributes,
+                        ast_entity_attributes,
+                        related_imports,
+                        relations_dependencies,
+                        pkey,
+                        prop,
                     )
 
-                    if (
-                        tenant
-                        and tenant != 0
-                        and grupo_empresarial
-                        and grupo_empresarial != "00000000-0000-0000-0000-000000000000"
-                    ):
-                        related_import = grupo_key
-                    elif tenant and tenant != 0:
-                        related_import = tenant_key
-                    else:
-                        related_import = default_key
-
-                    related_imports.append(
-                        (
-                            related_import,
-                            related_dto_class_name,
-                            related_entity_class_name,
-                        )
-                    )
-
-                    # Gravando a dependência de relacionamento
-                    relation_dependency = RelationDependency()
-                    relation_dependency.entity_resource = related_entity.api.resource
-                    relation_dependency.entity_scope = related_entity.escopo
-                    relation_dependency.tenant = tenant
-                    relation_dependency.grupo_empresarial = grupo_empresarial
-                    relations_dependencies.append(relation_dependency)
-
-                    # Instanciando o ast
-                    if prop.cardinality == CardinalityTypes.C1_N:
-                        # Para relacionamentos 1_N
-                        keywords = [
-                            ast.keyword(
-                                arg="dto_type",
-                                value=ast.Name(
-                                    id=related_dto_class_name, ctx=ast.Load()
-                                ),
-                            ),
-                            ast.keyword(
-                                arg="entity_type",
-                                value=ast.Name(
-                                    id=related_entity_class_name, ctx=ast.Load()
-                                ),
-                            ),
-                        ]
-
-                        # Resolvendo a coluna usada no relacionamento
-                        if (
-                            not properties_structure.entity_properties
-                            or pkey not in properties_structure.entity_properties
-                            or not properties_structure.entity_properties[
-                                pkey
-                            ].relation_column
-                        ):
-                            raise Exception(
-                                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
-                            )
-
-                        relation_column = properties_structure.entity_properties[
-                            pkey
-                        ].relation_column
-
-                        keywords.append(
-                            ast.keyword(
-                                arg="related_entity_field",
-                                value=ast.Constant(value=relation_column),
-                            )
-                        )
-
-                        ast_attr = ast.AnnAssign(
-                            target=ast.Name(
-                                id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()
-                            ),
-                            annotation=ast.Name(
-                                id="list",
-                                ctx=ast.Load(),
-                            ),
-                            value=ast.Call(
-                                func=ast.Name(id="DTOListField", ctx=ast.Load()),
-                                args=[],
-                                keywords=keywords,
-                            ),
-                            simple=1,
-                        )
-
-                        ast_dto_attributes.append(ast_attr)
-                    else:
-                        # TODO
-                        pass
-
-                elif re.match(REGEX_INTERNAL_REF, prop.type):
+                elif internal_match:
                     # TODO
                     pass
                 else:
-                    raise Exception(f"Tipo de propriedade não suportado: {prop.type}")
+                    raise Exception(
+                        f"Tipo da propriedade '{pkey}' não suportado: {prop.type}"
+                    )
+
+        for pkey in properties_structure.trait_properties:
+            prop = properties_structure.trait_properties[pkey]
+
+            self._compile_trait_property(
+                properties_structure,
+                map_unique_by_property,
+                pkey,
+                prop,
+                ast_dto_attributes,
+                ast_entity_attributes,
+                fixed_filters,
+                entity_model,
+                enum_classes,
+            )
 
         return (
             ast_dto_attributes,
@@ -226,9 +154,470 @@ class EDLPropertyCompiler:
             enum_classes,
             related_imports,
             relations_dependencies,
+            fixed_filters,
         )
 
-    def compile_simple_property(
+    def _compile_trait_property(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        map_unique_by_property: dict[str, IndexCompilerStructure],
+        pkey: str,
+        prop: TraitPropertyMetaModel,
+        ast_dto_attributes: list[ast.stmt],
+        ast_entity_attributes: list[ast.stmt],
+        fixed_filters: list[tuple[str, BasicTypes]],
+        entity_model: EntityModel,
+        enum_classes: list[ast.stmt],
+    ):
+        enum_class_name = None
+        keywords = []
+
+        if (
+            properties_structure.main_properties
+            and pkey in properties_structure.main_properties
+        ):
+            keywords.append(ast.keyword(arg="resume", value=ast.Constant(True)))
+
+        if properties_structure.required and pkey in properties_structure.required:
+            keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
+
+        if (
+            properties_structure.partition_data
+            and pkey in properties_structure.partition_data
+        ):
+            keywords.append(ast.keyword(arg="partition_data", value=ast.Constant(True)))
+
+        if pkey in map_unique_by_property:
+            unique = map_unique_by_property[pkey].index_model
+            keywords.append(
+                ast.keyword(
+                    arg="unique",
+                    value=ast.Constant(unique.name),
+                )
+            )
+
+        if (
+            properties_structure.search_properties
+            and pkey in properties_structure.search_properties
+        ):
+            keywords.append(ast.keyword(arg="search", value=ast.Constant(True)))
+        else:
+            keywords.append(ast.keyword(arg="search", value=ast.Constant(False)))
+
+        if (
+            properties_structure.metric_label
+            and pkey in properties_structure.metric_label
+        ):
+            keywords.append(ast.keyword(arg="metric_label", value=ast.Constant(True)))
+
+        if prop.type == PrimitiveTypes.CPF:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cpf",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.CNPJ:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cnpj",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.CPF_CNPJ:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cpf_or_cnpj",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.EMAIL:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_email",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+
+        # Trtando de uma definição de enum
+        if prop.domain_config:
+            result = self._compile_domain_config(pkey, prop, entity_model)
+            if not result:
+                raise Exception(f"Erro desconhecido ao compilar a propriedade {pkey}")
+
+            enum_class_name, ast_enum_class = result
+            enum_classes.append(ast_enum_class)
+
+        # Resolvendo o nome da propriedade no Entity
+        if (
+            properties_structure.entity_properties
+            and pkey in properties_structure.entity_properties
+        ):
+            entity_field_name = properties_structure.entity_properties[pkey].column
+        else:
+            entity_field_name = pkey
+
+        # Escrevendo, se necessário, o alias para o nome da entity
+        if entity_field_name != pkey:
+            keywords.append(
+                ast.keyword(
+                    arg="entity_field",
+                    value=ast.Constant(value=entity_field_name),
+                )
+            )
+
+        # Instanciando o atributo AST
+        if not isinstance(prop.type, PrimitiveTypes):
+            raise Exception(
+                f"Tipo da trait_property '{pkey}' não suportado: {prop.type} (deveria ser um Tipo Primitivo)"
+            )
+
+        # Instanciando o atributo AST
+        if enum_class_name:
+            prop_type = enum_class_name
+        else:
+            prop_type = TypeUtil.property_type_to_python_type(prop.type)
+
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id=prop_type,
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+        # Entity
+        ast_entity_attr = ast.AnnAssign(
+            target=ast.Name(
+                id=CompilerStrUtil.to_snake_case(entity_field_name),
+                ctx=ast.Store(),
+            ),
+            annotation=ast.Name(
+                id=TypeUtil.property_type_to_python_type(prop.type),
+                ctx=ast.Load(),
+            ),
+            value=ast.Constant(value=None),
+            simple=1,
+        )
+
+        ast_entity_attributes.append(ast_entity_attr)
+
+        # Guardando como um fixed_filter
+        # TODO Pernsar em validações para esse value (se está de acordo com o tipo ou enum)
+        fixed_filters.append((pkey, prop.value))
+
+    def _compile_external_relation(
+        self,
+        related_entity_id: str,
+        related_entity_key: str,
+        entity_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        ast_entity_attributes: list[ast.stmt],
+        related_imports: list[tuple[str, str, str]],
+        relations_dependencies: list[RelationDependency],
+        pkey: str,
+        prop: PropertyMetaModel,
+    ):
+        # Resolvendo o nome das classes de DTO e Entity
+        related_dto_class_name = compile_dto_class_name(related_entity_id)
+        related_entity_class_name = compile_entity_class_name(related_entity_id)
+
+        # Resolvendo o caminho do import
+        related_entity = entity_models.get(related_entity_key)
+        if not related_entity:
+            raise Exception(
+                f"Entidade '{entity_model.id}' possui uma referência externa para uma entidade inexistente: '{related_entity_key}', por meio da propriedade: '{pkey}'."
+            )
+
+        tenant = related_entity.tenant
+        grupo_empresarial = related_entity.grupo_empresarial
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant, grupo_empresarial
+        )
+
+        if (
+            tenant
+            and tenant != 0
+            and grupo_empresarial
+            and grupo_empresarial != "00000000-0000-0000-0000-000000000000"
+        ):
+            related_import = grupo_key
+        elif tenant and tenant != 0:
+            related_import = tenant_key
+        else:
+            related_import = default_key
+
+        related_imports.append(
+            (
+                related_import,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+        )
+
+        # Gravando a dependência de relacionamento
+        relation_dependency = RelationDependency()
+        relation_dependency.entity_resource = related_entity.api.resource
+        relation_dependency.entity_scope = related_entity.escopo
+        relation_dependency.tenant = tenant
+        relation_dependency.grupo_empresarial = grupo_empresarial
+        relations_dependencies.append(relation_dependency)
+
+        # Instanciando o ast
+        if prop.cardinality == CardinalityTypes.C1_N:
+            # Para relacionamentos 1_N
+            self._build_ast_1_N(
+                properties_structure,
+                ast_dto_attributes,
+                pkey,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+
+        elif prop.cardinality == CardinalityTypes.C1_1:
+            self._build_ast_1_1(
+                properties_structure,
+                ast_dto_attributes,
+                ast_entity_attributes,
+                pkey,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+
+        elif prop.cardinality == CardinalityTypes.CN_N:
+            # TODO
+            pass
+        else:
+            raise Exception(
+                f"Propriedade '{pkey}' da entidade '{entity_model.id}' possui cardinalidade inválida ou não suportada: {prop.cardinality}"
+            )
+
+    def _build_ast_1_N(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        pkey: str,
+        related_dto_class_name: str,
+        related_entity_class_name: str,
+    ):
+        # Propriedade do property descriptor
+        keywords = [
+            ast.keyword(
+                arg="dto_type",
+                value=ast.Name(id=related_dto_class_name, ctx=ast.Load()),
+            ),
+            ast.keyword(
+                arg="entity_type",
+                value=ast.Name(id=related_entity_class_name, ctx=ast.Load()),
+            ),
+        ]
+
+        # Resolvendo a coluna usada no relacionamento
+        if (
+            not properties_structure.entity_properties
+            or pkey not in properties_structure.entity_properties
+            or not properties_structure.entity_properties[pkey].relation_column
+        ):
+            raise Exception(
+                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
+            )
+
+        relation_column = properties_structure.entity_properties[pkey].relation_column
+
+        keywords.append(
+            ast.keyword(
+                arg="related_entity_field",
+                value=ast.Constant(value=relation_column),
+            )
+        )
+
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id="list",
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOListField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+    def _build_ast_1_1(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        ast_entity_attributes: list[ast.stmt],
+        pkey: str,
+        related_dto_class_name: str,
+        related_entity_class_name: str,
+    ):
+        # Propriedade do property descriptor
+        keywords = [
+            ast.keyword(
+                arg="entity_type",
+                value=ast.Name(id=related_entity_class_name, ctx=ast.Load()),
+            ),
+        ]
+
+        # Resolvendo a coluna usada no relacionamento
+        if (
+            not properties_structure.entity_properties
+            or pkey not in properties_structure.entity_properties
+            or not properties_structure.entity_properties[pkey].relation_column
+        ):
+            raise Exception(
+                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
+            )
+
+        relation_column = str(
+            properties_structure.entity_properties[pkey].relation_column
+        )
+
+        owner_relation = False
+        if "/" in relation_column:
+            owner_relation = True
+            relation_column = relation_column.split("/")[-1]
+
+        keywords.append(
+            ast.keyword(
+                arg="relation_field",
+                value=ast.Constant(value=relation_column),
+            )
+        )
+
+        if not owner_relation:
+            keywords.append(
+                ast.keyword(
+                    arg="entity_relation_owner",
+                    value=ast.Attribute(
+                        value=ast.Name(id="EntityRelationOwner", ctx=ast.Load()),
+                        attr="OTHER",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        else:
+            # Adicionando propriedade, para o campo de relação, no DTO (quando for o dono da relação)
+            ast_dto_attributes.append(
+                self._build_dto_property_ast(relation_column, PrimitiveTypes.UUID)
+            )
+
+            # Adicionando propriedade, para o campo de relação, no Entity (quando for o dono da relação)
+            ast_entity_attributes.append(
+                self._build_entity_property_ast(relation_column, PrimitiveTypes.UUID)
+            )
+
+        # Adicionando a propriedade em si do relacionamento, no DTO
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id=related_dto_class_name,
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOObjectField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+    def _build_dto_property_ast(
+        self,
+        name: str,
+        type: PrimitiveTypes | str,
+        keywords: list[ast.keyword] = [],
+    ):
+        if isinstance(type, PrimitiveTypes):
+            type_str = TypeUtil.property_type_to_python_type(type)
+        else:
+            type_str = type
+
+        return ast.AnnAssign(
+            target=ast.Name(
+                id=CompilerStrUtil.to_snake_case(name),
+                ctx=ast.Store(),
+            ),
+            annotation=ast.Name(
+                id=type_str,
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+    def _build_entity_property_ast(
+        self,
+        name: str,
+        type: PrimitiveTypes,
+    ):
+        return ast.AnnAssign(
+            target=ast.Name(
+                id=CompilerStrUtil.to_snake_case(name),
+                ctx=ast.Store(),
+            ),
+            annotation=ast.Name(
+                id=TypeUtil.property_type_to_python_type(type),
+                ctx=ast.Load(),
+            ),
+            value=ast.Constant(value=None),
+            simple=1,
+        )
+
+    def _compile_simple_property(
         self,
         properties_structure,
         map_unique_by_property,
@@ -438,42 +827,18 @@ class EDLPropertyCompiler:
         else:
             prop_type = TypeUtil.property_type_to_python_type(prop.type)
 
-        ast_attr = ast.AnnAssign(
-            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
-            annotation=ast.Name(
-                id=prop_type,
-                ctx=ast.Load(),
-            ),
-            value=ast.Call(
-                func=ast.Name(id="DTOField", ctx=ast.Load()),
-                args=[],
-                keywords=keywords,
-            ),
-            simple=1,
-        )
-
+        ast_attr = self._build_dto_property_ast(pkey, prop_type, keywords)
         ast_dto_attributes.append(ast_attr)
 
         # Entity
-        ast_entity_attr = ast.AnnAssign(
-            target=ast.Name(
-                id=CompilerStrUtil.to_snake_case(entity_field_name),
-                ctx=ast.Store(),
-            ),
-            annotation=ast.Name(
-                id=TypeUtil.property_type_to_python_type(prop.type),
-                ctx=ast.Load(),
-            ),
-            value=ast.Constant(value=None),
-            simple=1,
-        )
+        ast_entity_attr = self._build_entity_property_ast(entity_field_name, prop.type)
 
         ast_entity_attributes.append(ast_entity_attr)
 
     def _compile_domain_config(
         self,
         pkey: str,
-        prop: PropertyMetaModel,
+        prop: PropertyMetaModel | TraitPropertyMetaModel,
         entity_model: EntityModel,
     ) -> tuple[str, ast.stmt] | None:
         if not prop.domain_config:

nsj_rest_lib2/service/entity_loader.py

@@ -47,7 +47,7 @@ class EntityLoader:
         entity_resource: str,
         tenant: str | None,
         grupo_empresarial: str | None,
-        scope: str = ESCOPO_RESTLIB2,
+        escopo: str = ESCOPO_RESTLIB2,
     ) -> tuple[str, str, dict, bool, list[str]]:
         # Montando as chaves dos namespaces
         grupo_key, tenant_key, default_key = compile_namespace_keys(
@@ -103,6 +103,7 @@ class EntityLoader:
                     tenant_key,
                     default_key,
                     entity_config_key,
+                    escopo=escopo,
                 )
 
                 # Se não achar no redis, usa o que estava em memória
@@ -162,7 +163,12 @@ class EntityLoader:
 
         # Se não conseguir recuperar a entidade, procura no redis:
         loaded_config = self._load_entity_config_from_redis(
-            entity_resource, grupo_key, tenant_key, default_key, None
+            entity_resource,
+            grupo_key,
+            tenant_key,
+            default_key,
+            None,
+            escopo=escopo,
         )
 
         # Se também não achar no redis, lanca exceção
@@ -341,30 +347,31 @@ class EntityLoader:
         tenant_key: str,
         default_key: str,
         entity_config_key: str | None,
+        escopo: str,
     ) -> tuple[str, str] | None:
         get_logger().debug(
-            f"Procurando a configuração da entidade {entity_resource} no redis"
+            f"Procurando a configuração da entidade {entity_resource} no redis. Tenant key: {tenant_key} e Grupo key: {grupo_key}"
         )
 
         if entity_config_key is not None:
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, entity_config_key, entity_resource
+                "entity_config", escopo, entity_config_key, entity_resource
             )
 
         else:
             entity_config_key = grupo_key
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, grupo_key, entity_resource
+                "entity_config", escopo, grupo_key, entity_resource
             )
             if entity_config_str is None:
                 entity_config_key = tenant_key
                 entity_config_str = get_redis(
-                    "entity_config", ESCOPO_RESTLIB2, tenant_key, entity_resource
+                    "entity_config", escopo, tenant_key, entity_resource
                 )
             if entity_config_str is None:
                 entity_config_key = default_key
                 entity_config_str = get_redis(
-                    "entity_config", ESCOPO_RESTLIB2, default_key, entity_resource
+                    "entity_config", escopo, default_key, entity_resource
                 )
 
         # Se não encontrar no redis, retorna None

{nsj_rest_lib2-0.0.11.dist-info → nsj_rest_lib2-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.11
+Version: 0.0.13
 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

{nsj_rest_lib2-0.0.11.dist-info → nsj_rest_lib2-0.0.13.dist-info}/RECORD

@@ -4,22 +4,22 @@ nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU
 nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
 nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/ai_compiler.py,sha256=shAtN4T0ai_52qh15L3mK1QbeC6glHOR6C3J3gj14II,9029
-nsj_rest_lib2/compiler/compiler.py,sha256=bn780zjNHaopmhOzi0olMhwdh89uFJUKiCDRQActKGI,12243
+nsj_rest_lib2/compiler/compiler.py,sha256=tWnhDuHpvpJMWMPxt6U76ZS6J-hSpiB7xRZaeOP3CMc,12334
 nsj_rest_lib2/compiler/compiler_structures.py,sha256=2bM4_7lG1fytDGxJl6SU9pLsbspiNV36gVn9-O-23Q8,1009
-nsj_rest_lib2/compiler/dto_compiler.py,sha256=GAKWFvks0Duqs2EsEr1-BFx2-Kny72jJMbl9ZyIEDXw,4125
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=4e9_8EsNSHPCUEmiuEPdudj9_tFuw2O4ZTv6EYwJrGc,5333
 nsj_rest_lib2/compiler/entity_compiler.py,sha256=zLXO6USY4Rr0Hnk4wGep5K8DiHxJv-W-BBz_-g4OhCA,4307
 nsj_rest_lib2/compiler/model.py,sha256=QDBoM26qoZdiNcykl1nvXCrFDhg-6Q__QzVq6uY1QzE,1460
-nsj_rest_lib2/compiler/property_compiler.py,sha256=xVwql97vPdxln0z3zdigruYIujCA6978LfxGsLi6QhY,19527
+nsj_rest_lib2/compiler/property_compiler.py,sha256=AvJYY5vbmlodGjgyuCx6u17x0Qv3nEsAdMmBcSQP2f4,31153
 nsj_rest_lib2/compiler/edl_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/edl_model/ai_entity_edl.py,sha256=664QBDcOgVnyfwtUOXO1W7AKaZhueBG335x5DuogruY,7644
 nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=pH0Uiq_64AGvkHqwY44TrulWWZXbi6M0EKJWUhSqKj0,837
-nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=3OLsRwEz66Cktzew6Hie3HZXK9u20GXlWUU0HtFtwfk,709
+nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=s0sEVkoW1hV2_hto1mws4XhzKGH_b4NzhaOiwFH25Ks,694
 nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=sXVfC30P3-q2-fQ3XB_-3vpNjqFPIK5oBIVbwkXNFLU,3662
 nsj_rest_lib2/compiler/edl_model/index_model.py,sha256=cXWlu0hxtro5vvYoirkDW4R3PCnBW5oCCWjRJ6AX5zE,508
 nsj_rest_lib2/compiler/edl_model/primitives.py,sha256=cWEys87xDpgotyRUXkzvFvY4LHeawzBEEyz0Xed18AQ,1454
 nsj_rest_lib2/compiler/edl_model/property_meta_model.py,sha256=x2SApvI-5MZTErAHeOXnR6qfjflhSs8r6Y9KMtCykV0,3960
 nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=Vt1HxlaoifP4w5ij1laKDkD1-COBihE8EX1HkdEDUSo,977
-nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=ZC2oTvc9Y2Oiy4NLNHQLiMOLRWDAOdF8GJxOw4nqHdk,354
+nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=SBSfiu4v0PMsWRsGDySR3P2tkabLbDZxx_FFy_3rGXA,605
 nsj_rest_lib2/compiler/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/util/str_util.py,sha256=lVP1yHhj1pOd6ULtTnkcfX6Gqrpe4yCBratHUhBNGcI,843
 nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=sahlxtYUPcksqlX1hygaoTF7vuD8tY8eosgOR04YLAs,612
@@ -27,8 +27,8 @@ nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgK
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/controller/dynamic_controller.py,sha256=XMqxe1NW-NE5XwomXb4pSNdALQHpP74Hc26R4fnmXqg,15194
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_loader.py,sha256=es8qWyI0UNGf1wdEFnAmTYo8eW-XMIi7Ar_SgTfjQNQ,15224
-nsj_rest_lib2-0.0.11.dist-info/METADATA,sha256=xQRuH1m7gLxd3oW6Mh_e5iWRTSs660KlkSP7bes91FM,1361
-nsj_rest_lib2-0.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.11.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.11.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_loader.py,sha256=KVLFQSqj4DL-K-T29ksJE2or9QkekFmyAGUIKjQX6Qk,15372
+nsj_rest_lib2-0.0.13.dist-info/METADATA,sha256=mR2ZDZ5jbP18qsS288vSwD0tWDPOhibp_iyP-CrQ0Hk,1361
+nsj_rest_lib2-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.13.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.13.dist-info/RECORD,,