Arch/services/schema_service.py

import os
from datetime import datetime
import pytz
from flask import current_app
from utils.file_utils import load_json_file, save_json_file

def get_all_schemas():
    """
    Obtener todos los esquemas disponibles.
    
    Returns:
        dict: Diccionario de esquemas
    """
    storage_path = current_app.config['STORAGE_PATH']
    schema_file = os.path.join(storage_path, 'schemas', 'schema.json')
    
    return load_json_file(schema_file, {})

def get_schema(schema_code):
    """
    Obtener un esquema específico.
    
    Args:
        schema_code (str): Código del esquema
        
    Returns:
        dict: Datos del esquema o None si no existe
    """
    schemas = get_all_schemas()
    
    return schemas.get(schema_code)

def create_schema(schema_data, creator_username):
    """
    Crear un nuevo esquema.
    
    Args:
        schema_data (dict): Datos del esquema
        creator_username (str): Usuario que crea el esquema
        
    Returns:
        tuple: (success, message, schema_code)
    """
    # Validar datos obligatorios
    if 'descripcion' not in schema_data or not schema_data['descripcion']:
        return False, "La descripción del esquema es obligatoria.", None
    
    if 'documentos' not in schema_data or not schema_data['documentos']:
        return False, "Se requiere al menos un tipo de documento en el esquema.", None
    
    # Generar código de esquema
    schemas = get_all_schemas()
    
    # Encontrar el último código numérico
    last_code = 0
    for code in schemas.keys():
        if code.startswith('ESQ'):
            try:
                num = int(code[3:])
                if num > last_code:
                    last_code = num
            except ValueError:
                pass
    
    # Crear nuevo código
    schema_code = f"ESQ{last_code + 1:03d}"
    
    # Crear esquema
    schemas[schema_code] = {
        'codigo': schema_code,
        'descripcion': schema_data['descripcion'],
        'fecha_creacion': datetime.now(pytz.UTC).isoformat(),
        'creado_por': creator_username,
        'documentos': schema_data['documentos']
    }
    
    # Guardar esquemas
    storage_path = current_app.config['STORAGE_PATH']
    schema_file = os.path.join(storage_path, 'schemas', 'schema.json')
    save_json_file(schema_file, schemas)
    
    return True, "Esquema creado correctamente.", schema_code

def update_schema(schema_code, schema_data):
    """
    Actualizar un esquema existente.
    
    Args:
        schema_code (str): Código del esquema
        schema_data (dict): Datos actualizados
        
    Returns:
        tuple: (success, message)
    """
    schemas = get_all_schemas()
    
    # Verificar si existe el esquema
    if schema_code not in schemas:
        return False, f"No se encontró el esquema con código {schema_code}."
    
    # Actualizar campos permitidos
    if 'descripcion' in schema_data:
        schemas[schema_code]['descripcion'] = schema_data['descripcion']
    
    if 'documentos' in schema_data:
        schemas[schema_code]['documentos'] = schema_data['documentos']
    
    # Guardar esquemas
    storage_path = current_app.config['STORAGE_PATH']
    schema_file = os.path.join(storage_path, 'schemas', 'schema.json')
    save_json_file(schema_file, schemas)
    
    return True, "Esquema actualizado correctamente."

def delete_schema(schema_code):
    """
    Eliminar un esquema.
    
    Args:
        schema_code (str): Código del esquema
        
    Returns:
        tuple: (success, message)
    """
    schemas = get_all_schemas()
    
    # Verificar si existe el esquema
    if schema_code not in schemas:
        return False, f"No se encontró el esquema con código {schema_code}."
    
    # Eliminar esquema
    del schemas[schema_code]
    
    # Guardar esquemas
    storage_path = current_app.config['STORAGE_PATH']
    schema_file = os.path.join(storage_path, 'schemas', 'schema.json')
    save_json_file(schema_file, schemas)
    
    return True, "Esquema eliminado correctamente."

def get_schema_document_types(schema_code):
    """
    Obtener los tipos de documento definidos en un esquema.
    
    Args:
        schema_code (str): Código del esquema
        
    Returns:
        list: Lista de tipos de documento
    """
    schema = get_schema(schema_code)
    
    if not schema:
        return []
    
    return schema.get('documentos', [])

def validate_document_for_schema(schema_code, document_type):
    """
    Validar si un tipo de documento está permitido en un esquema.
    
    Args:
        schema_code (str): Código del esquema
        document_type (str): Tipo de documento
        
    Returns:
        tuple: (is_valid, required_level) - Validez y nivel requerido
    """
    schema = get_schema(schema_code)
    
    if not schema:
        return False, None
    
    for doc in schema.get('documentos', []):
        if doc.get('tipo') == document_type:
            return True, doc.get('nivel_editar', 0)
    
    return False, None

def initialize_default_schemas():
    """
    Inicializar esquemas predeterminados si no existen.
    """
    schemas = get_all_schemas()
    
    if not schemas:
        # Crear esquema estándar
        create_schema({
            'descripcion': 'Proyecto estándar',
            'documentos': [
                {
                    'tipo': 'pdf',
                    'nombre': 'Manual de Usuario',
                    'nivel_ver': 0,
                    'nivel_editar': 5000
                },
                {
                    'tipo': 'txt',
                    'nombre': 'Notas del Proyecto',
                    'nivel_ver': 0,
                    'nivel_editar': 1000
                },
                {
                    'tipo': 'zip',
                    'nombre': 'Archivos Fuente',
                    'nivel_ver': 1000,
                    'nivel_editar': 5000
                }
            ]
        }, 'admin')
        
        current_app.logger.info('Esquema predeterminado creado.')