149 lines
5.9 KiB
Python
149 lines
5.9 KiB
Python
from app import db
|
|
from datetime import datetime
|
|
from app.services.crypto_service import CryptoService
|
|
|
|
class _hybrid_setting_method:
|
|
"""Descriptor que resuelve si se invoca sobre la clase SystemSetting o sobre una instancia."""
|
|
def __init__(self, inst_func, cls_func):
|
|
self.inst_func = inst_func
|
|
self.cls_func = cls_func
|
|
|
|
def __get__(self, instance, owner):
|
|
if instance is None:
|
|
return lambda *args, **kwargs: self.cls_func(owner, *args, **kwargs)
|
|
return lambda *args, **kwargs: self.inst_func(instance, *args, **kwargs)
|
|
|
|
|
|
class SystemSetting(db.Model):
|
|
"""
|
|
Parámetros de configuración del sistema persistentes en base de datos.
|
|
Permite almacenar enlaces de integración (e.g. Google Sheets, Moodle),
|
|
flags globales, credenciales SMTP encriptadas y secretos OAuth.
|
|
"""
|
|
__tablename__ = 'system_settings'
|
|
|
|
id = db.Column(db.Integer, primary_key=True)
|
|
key = db.Column(db.String(100), unique=True, nullable=False, index=True)
|
|
value = db.Column(db.Text, nullable=True)
|
|
description = db.Column(db.String(255), nullable=True)
|
|
category = db.Column(db.String(50), default='system', nullable=True)
|
|
is_encrypted = db.Column(db.Boolean, default=False, nullable=True)
|
|
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
|
|
|
|
def __init__(self, **kwargs):
|
|
super().__init__(**kwargs)
|
|
|
|
@classmethod
|
|
def get_value(cls, key, default=None):
|
|
"""Retorna el valor tal como está almacenado en BD."""
|
|
try:
|
|
record = cls.query.filter_by(key=key).first()
|
|
if record and record.value is not None and record.value.strip() != '':
|
|
return record.value
|
|
except Exception:
|
|
pass
|
|
return default
|
|
|
|
def _inst_get_decrypted_value(self, default=None):
|
|
try:
|
|
if self.value is not None and self.value.strip() != '':
|
|
if self.is_encrypted:
|
|
return CryptoService.decrypt(self.value)
|
|
return self.value
|
|
except Exception:
|
|
pass
|
|
return default
|
|
|
|
@classmethod
|
|
def _cls_get_decrypted_value(cls, key, default=None):
|
|
try:
|
|
record = cls.query.filter_by(key=key).first()
|
|
if record and record.value is not None and record.value.strip() != '':
|
|
if record.is_encrypted:
|
|
return CryptoService.decrypt(record.value)
|
|
return record.value
|
|
except Exception:
|
|
pass
|
|
return default
|
|
|
|
get_decrypted_value = _hybrid_setting_method(_inst_get_decrypted_value, _cls_get_decrypted_value)
|
|
|
|
def _inst_get_masked_value(self, default=''):
|
|
try:
|
|
if self.value and self.value.strip() != '':
|
|
k_lower = (self.key or '').lower()
|
|
if self.is_encrypted or any(x in k_lower for x in ('secret', 'password', 'token', 'key')):
|
|
return '••••••••••••'
|
|
return self.value
|
|
except Exception:
|
|
pass
|
|
return default
|
|
|
|
@classmethod
|
|
def _cls_get_masked_value(cls, key, default=''):
|
|
try:
|
|
record = cls.query.filter_by(key=key).first()
|
|
if record and record.value and record.value.strip() != '':
|
|
k_lower = record.key.lower()
|
|
if record.is_encrypted or any(x in k_lower for x in ('secret', 'password', 'token', 'key')):
|
|
return '••••••••••••'
|
|
return record.value
|
|
except Exception:
|
|
pass
|
|
return default
|
|
|
|
get_masked_value = _hybrid_setting_method(_inst_get_masked_value, _cls_get_masked_value)
|
|
|
|
@classmethod
|
|
def set_value(cls, key, value, description=None, category='system', is_encrypted=False):
|
|
"""Guarda o actualiza un parámetro de configuración."""
|
|
record = cls.query.filter_by(key=key).first()
|
|
final_value = value
|
|
if is_encrypted and value:
|
|
# Si el valor ya viene cifrado o es un placeholder de no-cambio '••••••••••••', no recifrar
|
|
if value != '••••••••••••':
|
|
final_value = CryptoService.encrypt(value)
|
|
|
|
if not record:
|
|
record = cls(
|
|
key=key,
|
|
value=final_value,
|
|
description=description,
|
|
category=category,
|
|
is_encrypted=is_encrypted
|
|
)
|
|
db.session.add(record)
|
|
else:
|
|
# Si el valor ingresado es el placeholder, no sobrescribir la contraseña existente
|
|
if not (is_encrypted and value == '••••••••••••'):
|
|
record.value = final_value
|
|
if description:
|
|
record.description = description
|
|
if category:
|
|
record.category = category
|
|
record.is_encrypted = is_encrypted
|
|
record.updated_at = datetime.utcnow()
|
|
db.session.commit()
|
|
return record
|
|
|
|
@classmethod
|
|
def set_encrypted_value(cls, key, value, description=None, category='system'):
|
|
"""Helper para guardar directamente valores sensibles cifrados."""
|
|
return cls.set_value(key, value, description=description, category=category, is_encrypted=True)
|
|
|
|
def to_dict(self, mask_secrets=True):
|
|
val = self.value
|
|
if mask_secrets and (self.is_encrypted or 'password' in self.key.lower() or 'secret' in self.key.lower() or 'token' in self.key.lower()):
|
|
val = '••••••••••••' if val else ''
|
|
return {
|
|
'key': self.key,
|
|
'value': val,
|
|
'description': self.description,
|
|
'category': self.category or 'system',
|
|
'is_encrypted': bool(self.is_encrypted),
|
|
'updated_at': self.updated_at.isoformat() if self.updated_at else None
|
|
}
|
|
|
|
def __repr__(self):
|
|
return f'<SystemSetting {self.key}>'
|