Update entity_relationship_generator.py

entity_relationship_generator.py

@@ -319,107 +319,70 @@ def generate_entity_relationship_diagram(json_input: str, output_format: str) ->
           "name": "EMPLEADO",
           "type": "strong",
           "attributes": [
-            {"name": "RUT", "type": "primary_key"},
-            {"name": "Nombre", "type": "regular"},
-            {"name": "Apellido1", "type": "regular"},
-            {"name": "Apellido2", "type": "regular"},
-            {"name": "Dirección", "type": "regular"},
-            {"name": "Sexo", "type": "regular"},
-            {"name": "Salario", "type": "regular"},
-            {"name": "FechaN", "type": "regular"}
+            {"name": "num_matricula", "type": "primary_key"},
+            {"name": "nombre", "type": "regular"},
+            {"name": "direccion", "type": "regular"}
           ]
         },
         {
-          "name": "DEPARTAMENTO",
+          "name": "DEPARTAMENTO", 
           "type": "strong",
           "attributes": [
-            {"name": "Número", "type": "primary_key"},
-            {"name": "Nombre", "type": "regular"},
-            {"name": "Localizaciones", "type": "multivalued"}
+            {"name": "cod_depto", "type": "primary_key"},
+            {"name": "nombre_depto", "type": "regular"}
           ]
         },
         {
-          "name": "PROYECTO",
+          "name": "TECNICO",
           "type": "strong",
           "attributes": [
-            {"name": "Número", "type": "primary_key"},
-            {"name": "Nombre", "type": "regular"},
-            {"name": "Localización", "type": "regular"}
+            {"name": "nivel", "type": "regular"}
           ]
         },
         {
-          "name": "DEPENDIENTE",
-          "type": "weak",
+          "name": "ADMINISTRATIVO",
+          "type": "strong", 
+          "attributes": []
+        },
+        {
+          "name": "PROYECTO",
+          "type": "strong",
           "attributes": [
-            {"name": "Nombre", "type": "partial_key"},
-            {"name": "Sexo", "type": "regular"},
-            {"name": "FechaN", "type": "regular"},
-            {"name": "Relación", "type": "regular"}
+            {"name": "cod_proyecto", "type": "primary_key"},
+            {"name": "nombre_proyecto", "type": "regular"},
+            {"name": "cliente", "type": "regular"},
+            {"name": "fecha_inicio", "type": "regular"},
+            {"name": "fecha_fin", "type": "regular"}
           ]
         }
       ],
       "relationships": [
         {
-          "name": "TRABAJA_PARA",
+          "name": "Pertenece",
           "type": "regular",
           "entities": ["EMPLEADO", "DEPARTAMENTO"],
           "cardinalities": {
             "EMPLEADO": "N",
             "DEPARTAMENTO": "1"
-          }
-        },
-        {
-          "name": "ADMINISTRA",
-          "type": "regular",
-          "entities": ["EMPLEADO", "DEPARTAMENTO"],
-          "cardinalities": {
-            "EMPLEADO": "1",
-            "DEPARTAMENTO": "1"
           },
           "attributes": [
-            {"name": "FechaInicio", "type": "regular"}
+            {"name": "fecha_asignacion", "type": "regular"},
+            {"name": "fecha_cese", "type": "regular"}
           ]
         },
         {
-          "name": "CONTROLA",
-          "type": "regular",
-          "entities": ["DEPARTAMENTO", "PROYECTO"],
-          "cardinalities": {
-            "DEPARTAMENTO": "1",
-            "PROYECTO": "N"
-          }
+          "name": "Es_un",
+          "type": "isa",
+          "parent": "EMPLEADO",
+          "children": ["TECNICO", "ADMINISTRATIVO"]
         },
         {
-          "name": "SUPERVISIÓN",
+          "name": "Trabaja_en",
           "type": "regular",
-          "entities": ["EMPLEADO", "EMPLEADO"],
+          "entities": ["TECNICO", "PROYECTO"],
           "cardinalities": {
-            "EMPLEADO": "1",
-            "EMPLEADO": "N"
-          },
-          "roles": {
-            "EMPLEADO": ["supervisor", "supervisado"]
-          }
-        },
-        {
-          "name": "TRABAJA_PARA_PROYECTO",
-          "type": "ternary",
-          "entities": ["EMPLEADO", "PROYECTO"],
-          "cardinalities": {
-            "EMPLEADO": "M",
+            "TECNICO": "M",
             "PROYECTO": "N"
-          },
-          "attributes": [
-            {"name": "Horas", "type": "regular"}
-          ]
-        },
-        {
-          "name": "DEPENDIENTES",
-          "type": "identifying",
-          "entities": ["EMPLEADO", "DEPENDIENTE"],
-          "cardinalities": {
-            "EMPLEADO": "1",
-            "DEPENDIENTE": "N"
           }
         }
       ]
@@ -437,15 +400,25 @@ def generate_entity_relationship_diagram(json_input: str, output_format: str) ->
         if 'entities' not in data:
             raise ValueError("Missing required field: entities")
 
+        # Crear grafo con estilo mejorado
         dot = graphviz.Graph(comment='ER Diagram', engine='dot')
-        dot.attr(rankdir='TB', bgcolor='white', pad='0.5', nodesep='1.0', ranksep='1.5')
-        dot.attr('node', fontname='Arial', fontsize='10', color='black')
-        dot.attr('edge', fontname='Arial', fontsize='9', color='black')
+        dot.attr(
+            rankdir='TB', 
+            bgcolor='white', 
+            pad='0.8',
+            nodesep='1.2', 
+            ranksep='1.8',
+            fontname='Arial'
+        )
+        
+        # Configuración base de nodos y aristas
+        dot.attr('node', fontname='Arial', fontsize='11', color='#404040')
+        dot.attr('edge', fontname='Arial', fontsize='10', color='#404040')
         
         entities = data.get('entities', [])
         relationships = data.get('relationships', [])
         
-        # Crear entidades
+        # Crear entidades con estilo profesional
         for entity in entities:
             entity_name = entity.get('name')
             entity_type = entity.get('type', 'strong')
@@ -453,110 +426,195 @@ def generate_entity_relationship_diagram(json_input: str, output_format: str) ->
             if not entity_name:
                 continue
             
-            # Entidades fuertes: rectángulo simple
-            # Entidades débiles: rectángulo doble (simulado con penwidth)
             if entity_type == 'weak':
-                dot.node(entity_name, entity_name, shape='box', style='filled', 
-                        fillcolor='white', color='black', penwidth='3')
+                # Entidad débil: doble rectángulo (simulado con tabla HTML)
+                label = f'<<TABLE BORDER="3" CELLBORDER="1" CELLSPACING="0" CELLPADDING="8" BGCOLOR="#f0f0f0"><TR><TD><B>{entity_name}</B></TD></TR></TABLE>>'
+                dot.node(entity_name, label, shape='plaintext')
             else:
-                dot.node(entity_name, entity_name, shape='box', style='filled', 
-                        fillcolor='white', color='black', penwidth='1')
+                # Entidad fuerte: rectángulo simple con estilo
+                dot.node(
+                    entity_name, 
+                    entity_name, 
+                    shape='box', 
+                    style='filled,rounded', 
+                    fillcolor='#e8e8e8',
+                    color='#404040',
+                    penwidth='2',
+                    fontsize='12',
+                    fontcolor='#000000'
+                )
         
         # Crear atributos para cada entidad
         for entity in entities:
             entity_name = entity.get('name')
             attributes = entity.get('attributes', [])
             
-            for attr in attributes:
+            for i, attr in enumerate(attributes):
                 attr_name = attr.get('name', '')
                 attr_type = attr.get('type', 'regular')
                 
-                attr_id = f"{entity_name}_{attr_name}"
+                attr_id = f"{entity_name}_attr_{i}"
                 
                 if attr_type == 'primary_key':
-                    # Atributo clave: elipse con texto subrayado
-                    dot.node(attr_id, f"<U>{attr_name}</U>", shape='ellipse', 
-                            style='filled', fillcolor='white', color='black')
+                    # Clave primaria: elipse con texto subrayado
+                    dot.node(
+                        attr_id, 
+                        f'<U><B>{attr_name}</B></U>', 
+                        shape='ellipse', 
+                        style='filled',
+                        fillcolor='#d0d0d0',
+                        color='#404040',
+                        penwidth='2'
+                    )
                 elif attr_type == 'partial_key':
                     # Clave parcial: elipse con línea punteada
-                    dot.node(attr_id, f"<U>{attr_name}</U>", shape='ellipse', 
-                            style='filled,dashed', fillcolor='white', color='black')
+                    dot.node(
+                        attr_id, 
+                        f'<U>{attr_name}</U>', 
+                        shape='ellipse', 
+                        style='filled,dashed',
+                        fillcolor='#d0d0d0',
+                        color='#404040',
+                        penwidth='2'
+                    )
                 elif attr_type == 'multivalued':
-                    # Atributo multivaluado: doble elipse (simulado con penwidth)
-                    dot.node(attr_id, attr_name, shape='ellipse', 
-                            style='filled', fillcolor='white', color='black', penwidth='3')
+                    # Atributo multivaluado: doble elipse (tabla HTML)
+                    label = f'<<TABLE BORDER="2" CELLBORDER="0" CELLSPACING="0" CELLPADDING="4" BGCOLOR="#d8d8d8"><TR><TD>{attr_name}</TD></TR></TABLE>>'
+                    dot.node(attr_id, label, shape='plaintext')
                 elif attr_type == 'derived':
                     # Atributo derivado: elipse con línea punteada
-                    dot.node(attr_id, attr_name, shape='ellipse', 
-                            style='filled,dashed', fillcolor='white', color='black')
+                    dot.node(
+                        attr_id, 
+                        f'/{attr_name}/', 
+                        shape='ellipse', 
+                        style='filled,dashed',
+                        fillcolor='#d8d8d8',
+                        color='#404040'
+                    )
                 elif attr_type == 'composite':
-                    # Atributo compuesto: elipse normal (los componentes se conectarían por separado)
-                    dot.node(attr_id, attr_name, shape='ellipse', 
-                            style='filled', fillcolor='white', color='black')
+                    # Atributo compuesto
+                    dot.node(
+                        attr_id, 
+                        attr_name, 
+                        shape='ellipse', 
+                        style='filled',
+                        fillcolor='#d8d8d8',
+                        color='#404040'
+                    )
                 else:
-                    # Atributo regular: elipse simple
-                    dot.node(attr_id, attr_name, shape='ellipse', 
-                            style='filled', fillcolor='white', color='black')
+                    # Atributo regular
+                    dot.node(
+                        attr_id, 
+                        attr_name, 
+                        shape='ellipse', 
+                        style='filled',
+                        fillcolor='#d8d8d8',
+                        color='#404040'
+                    )
                 
                 # Conectar atributo con entidad
-                dot.edge(entity_name, attr_id, color='black')
+                dot.edge(entity_name, attr_id, color='#404040', penwidth='1')
         
         # Crear relaciones
         for relationship in relationships:
             rel_name = relationship.get('name')
             rel_type = relationship.get('type', 'regular')
-            entities_involved = relationship.get('entities', [])
-            cardinalities = relationship.get('cardinalities', {})
-            rel_attributes = relationship.get('attributes', [])
-            roles = relationship.get('roles', {})
             
-            if not rel_name or len(entities_involved) < 2:
-                continue
-            
-            # Relaciones identificadoras: rombo doble
-            # Relaciones regulares: rombo simple
-            if rel_type == 'identifying':
-                dot.node(rel_name, rel_name, shape='diamond', style='filled', 
-                        fillcolor='white', color='black', penwidth='3')
+            if rel_type == 'isa':
+                # Relación ISA (jerarquía)
+                parent = relationship.get('parent')
+                children = relationship.get('children', [])
+                
+                if parent and children:
+                    # Crear nodo ISA como triángulo
+                    isa_id = f"isa_{rel_name}"
+                    dot.node(
+                        isa_id, 
+                        'ISA', 
+                        shape='triangle', 
+                        style='filled',
+                        fillcolor='#c0c0c0',
+                        color='#404040',
+                        penwidth='2'
+                    )
+                    
+                    # Conectar padre con ISA
+                    dot.edge(parent, isa_id, color='#404040', penwidth='2')
+                    
+                    # Conectar ISA con hijos
+                    for child in children:
+                        dot.edge(isa_id, child, color='#404040', penwidth='2')
+                
             else:
-                dot.node(rel_name, rel_name, shape='diamond', style='filled', 
-                        fillcolor='white', color='black', penwidth='1')
-            
-            # Crear atributos de la relación
-            for attr in rel_attributes:
-                attr_name = attr.get('name', '')
-                attr_type = attr.get('type', 'regular')
-                attr_id = f"{rel_name}_{attr_name}"
+                # Relación regular
+                entities_involved = relationship.get('entities', [])
+                cardinalities = relationship.get('cardinalities', {})
+                rel_attributes = relationship.get('attributes', [])
                 
-                dot.node(attr_id, attr_name, shape='ellipse', 
-                        style='filled', fillcolor='white', color='black')
-                dot.edge(rel_name, attr_id, color='black')
-            
-            # Conectar entidades con la relación
-            if len(entities_involved) == 2 and entities_involved[0] == entities_involved[1]:
-                # Relación reflexiva (como supervisión)
-                entity = entities_involved[0]
-                cardinality1 = cardinalities.get(entity, '1')
+                if not rel_name or len(entities_involved) < 2:
+                    continue
                 
-                # Para relaciones reflexivas, necesitamos crear dos conexiones
-                dot.edge(entity, rel_name, label=cardinality1, color='black')
-                dot.edge(entity, rel_name, label='N', color='black')
+                rel_type_style = relationship.get('type', 'regular')
                 
-                # Agregar roles si están definidos
-                if roles and entity in roles:
-                    role_list = roles[entity]
-                    if len(role_list) >= 2:
-                        # Crear nodos de texto para los roles
-                        role1_id = f"{rel_name}_role1"
-                        role2_id = f"{rel_name}_role2"
-                        dot.node(role1_id, role_list[0], shape='plaintext', fontsize='8')
-                        dot.node(role2_id, role_list[1], shape='plaintext', fontsize='8')
-            else:
-                # Relación normal entre diferentes entidades
+                if rel_type_style == 'identifying':
+                    # Relación identificadora: doble rombo
+                    label = f'<<TABLE BORDER="3" CELLBORDER="0" CELLSPACING="0" CELLPADDING="6" BGCOLOR="#c8c8c8"><TR><TD><B>{rel_name}</B></TD></TR></TABLE>>'
+                    dot.node(rel_name, label, shape='plaintext')
+                else:
+                    # Relación regular: rombo simple
+                    dot.node(
+                        rel_name, 
+                        rel_name, 
+                        shape='diamond', 
+                        style='filled',
+                        fillcolor='#c8c8c8',
+                        color='#404040',
+                        penwidth='2'
+                    )
+                
+                # Crear atributos de la relación
+                for i, attr in enumerate(rel_attributes):
+                    attr_name = attr.get('name', '')
+                    attr_id = f"{rel_name}_attr_{i}"
+                    
+                    dot.node(
+                        attr_id, 
+                        attr_name, 
+                        shape='ellipse', 
+                        style='filled',
+                        fillcolor='#d8d8d8',
+                        color='#404040'
+                    )
+                    dot.edge(rel_name, attr_id, color='#404040')
+                
+                # Conectar entidades con la relación
                 for entity in entities_involved:
                     cardinality = cardinalities.get(entity, '1')
-                    dot.edge(entity, rel_name, label=cardinality, color='black')
+                    
+                    if len(entities_involved) == 2 and entities_involved[0] == entities_involved[1]:
+                        # Relación reflexiva
+                        dot.edge(
+                            entity, 
+                            rel_name, 
+                            label=cardinality, 
+                            color='#404040',
+                            penwidth='2',
+                            fontsize='10',
+                            fontcolor='#000000'
+                        )
+                    else:
+                        # Relación normal
+                        dot.edge(
+                            entity, 
+                            rel_name, 
+                            label=cardinality, 
+                            color='#404040',
+                            penwidth='2',
+                            fontsize='10',
+                            fontcolor='#000000'
+                        )
 
+        # Renderizar el diagrama
         with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
             dot.render(tmp.name, format=output_format, cleanup=True)
             return f"{tmp.name}.{output_format}"
@@ -564,4 +622,4 @@ def generate_entity_relationship_diagram(json_input: str, output_format: str) ->
     except json.JSONDecodeError:
         return "Error: Invalid JSON format"
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error: {str(e)}"