257 lines
9.9 KiB
Python
257 lines
9.9 KiB
Python
from rest_framework import serializers
|
|
from rest_framework.validators import ValidationError
|
|
from django.contrib.auth import get_user_model
|
|
from allauth.account.models import EmailAddress
|
|
from django.contrib.auth.models import Permission, User
|
|
from Sistemas.models import Sistema
|
|
from .models import ClientesA24, Sistemas_por_cliente_A24, DeviceA24,Modulo, Permisos_A24
|
|
|
|
|
|
class CustomPermissionSerializer(serializers.ModelSerializer):
|
|
activo = serializers.BooleanField(read_only=True)
|
|
# user_id = serializers.SerializerMethodField()
|
|
class Meta:
|
|
model = Permission
|
|
fields = '__all__'
|
|
def get_user_id(self, obj):
|
|
# Obtenemos el ID del usuario asociado al permiso si existe
|
|
user = User.objects.filter(user_permissions=obj).first()
|
|
return user.id if user else None
|
|
|
|
class ModulosSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model=Modulo
|
|
fields = '__all__'
|
|
depth =1
|
|
|
|
def create(self, validated_data):
|
|
"""Se recive el json completo para poder tomar los permisos """
|
|
try:
|
|
permisos_data= self.context.get('request').data.get('permisos', [])
|
|
modulo = super(ModulosSerializer,self).create(validated_data)
|
|
|
|
for permiso_id in permisos_data:
|
|
permiso, created= Permisos_A24.objects.get_or_create(pk=permiso_id,\
|
|
defaults={'nombre': f'{modulo.nombre}_{permiso_id}'})
|
|
modulo.permisos.add(permiso)
|
|
return modulo
|
|
except Exception as e:
|
|
raise ValidationError({'error':str(e)})
|
|
|
|
class Permisos_A24_Serializer(serializers.ModelSerializer):
|
|
modulo = serializers.CharField(write_only=True, required=False)
|
|
modulos = serializers.SerializerMethodField()
|
|
class Meta:
|
|
model = Permisos_A24
|
|
fields = ['id','nombre',
|
|
'modulo',
|
|
'modulos']
|
|
|
|
def create(self,validated_data):
|
|
""""""
|
|
try:
|
|
|
|
modulo_nombre = validated_data.pop('modulo',None)
|
|
permiso = super(Permisos_A24_Serializer, self).create(validated_data)
|
|
if modulo_nombre:
|
|
modulo, created = Modulo.objects.get_or_create(nombre=modulo_nombre, \
|
|
defaults={'nombre':modulo_nombre})
|
|
modulo.permisos.add(permiso)
|
|
permiso.modulo = modulo.nombre
|
|
return permiso
|
|
except Exception as e:
|
|
raise ValidationError({'error':str(e)})
|
|
|
|
def to_representation(self, instance):
|
|
representation = super(Permisos_A24_Serializer, self).to_representation(instance)
|
|
|
|
# Agregar el atributo 'modulo' al JSON de respuesta si está presente
|
|
if hasattr(instance, 'modulo') and instance.modulo:
|
|
representation['modulo'] = instance.modulo
|
|
|
|
return representation
|
|
|
|
def get_modulos(self, obj):
|
|
# Obtener la lista de nombres de los módulos a los que está asignado el permiso
|
|
return list(obj.modulo_set.values_list('nombre', flat=True))
|
|
|
|
class Sistema_A24_PKRF(serializers.PrimaryKeyRelatedField):
|
|
def to_internal_value(self,data):
|
|
try:
|
|
return Sistema.objects.get(nombre_sistema=data)
|
|
except Sistema.DoesNotExist:
|
|
raise serializers.ValidationError("Sistema no existe")
|
|
|
|
class ClientA24_PKRF(serializers.PrimaryKeyRelatedField):
|
|
def to_internal_value(self,data):
|
|
try:
|
|
return ClientesA24.objects.get(RFC=data)
|
|
except ClientesA24.DoesNotExist:
|
|
raise serializers.ValidationError("No existe Cliente")
|
|
|
|
class ClientA24_Create_PKRF(serializers.PrimaryKeyRelatedField):
|
|
def to_internal_value(self,data):
|
|
try:
|
|
return ClientesA24.objects.get(RFC=data)
|
|
except ClientesA24.DoesNotExist:
|
|
return None
|
|
|
|
#--------SERAILIZERS
|
|
|
|
class Sistema_Serializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Sistema
|
|
fields = ('nombre_sistema',)
|
|
|
|
class ClientesA24Serailizer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model =ClientesA24
|
|
fields = ('pk','RFC', 'Nombre','Activo','fecha_baja',)
|
|
|
|
class DeviceA24_admin_Serialiazer(serializers.ModelSerializer):
|
|
clienteA24 = serializers.SerializerMethodField()
|
|
sistema = serializers.SerializerMethodField()
|
|
deviceName = serializers.CharField(required=True)
|
|
deviceOS= serializers.CharField(required=False)
|
|
deviceIP = serializers.CharField(required=False)
|
|
username = serializers.CharField(required=False)
|
|
dataBase = serializers.CharField(required=True)
|
|
|
|
class Meta:
|
|
model = DeviceA24
|
|
fields = '__all__'
|
|
|
|
def get_clienteA24(self, obj):
|
|
return obj.clienteA24.RFC if obj.clienteA24.RFC else ""
|
|
def get_sistema(self,obj):
|
|
return obj.sistema.nombre_sistema if obj.sistema.nombre_sistema else ""
|
|
|
|
|
|
|
|
class SerialiazerA24(serializers.ModelSerializer):
|
|
clienteA24 = ClientA24_PKRF(queryset=ClientesA24.objects.all())
|
|
sistema = Sistema_A24_PKRF(queryset=Sistema.objects.all())
|
|
|
|
token = serializers.CharField(read_only=True)
|
|
class Meta:
|
|
model = DeviceA24
|
|
fields= ('clienteA24', 'deviceName', 'deviceOS', 'deviceIP', 'token', 'sistema', 'MAC', 'dataBase',)
|
|
|
|
def create(self, validated_data):
|
|
# Extraer los datos obligatorios de la solicitud
|
|
clienteA24 = validated_data['clienteA24']
|
|
deviceName = validated_data['deviceName']
|
|
deviceOS = validated_data['deviceOS']
|
|
deviceIP = validated_data['deviceIP']
|
|
MAC = validated_data['MAC']
|
|
sistema=validated_data['sistema']
|
|
dataBase = validated_data['dataBase']
|
|
|
|
# Verificar si ya existe un dispositivo con los mismos datos
|
|
existing_device = DeviceA24.objects.filter(
|
|
clienteA24=clienteA24,
|
|
#deviceName=deviceName,
|
|
#deviceOS=deviceOS,
|
|
#deviceIP=deviceIP,
|
|
MAC=MAC,
|
|
sistema=sistema,
|
|
dataBase=dataBase
|
|
).first()
|
|
|
|
if existing_device:
|
|
# Si ya existe un dispositivo con los mismos datos, puedes devolverlo
|
|
return existing_device
|
|
|
|
# Si no existe, crear un nuevo objeto DeviceA24
|
|
device_a24 = DeviceA24.objects.create(
|
|
clienteA24=clienteA24,
|
|
deviceName=deviceName,
|
|
deviceOS=deviceOS,
|
|
deviceIP=deviceIP,
|
|
MAC=MAC,
|
|
sistema=sistema,
|
|
dataBase=dataBase,
|
|
)
|
|
|
|
# Generar el nombre de usuario y otros campos automáticos
|
|
device_a24.username = device_a24.generate_username(clienteA24, deviceName, MAC)
|
|
device_a24.save() # Guardar para generar el timestamp
|
|
|
|
return device_a24
|
|
|
|
class Sistema_Por_Cliente_Serializer(serializers.ModelSerializer):
|
|
id_sistema = Sistema_A24_PKRF(queryset=Sistema.objects.all())
|
|
cliente = ClientA24_Create_PKRF(queryset=ClientesA24.objects.all())
|
|
clienteA24 = serializers.CharField(read_only=True)
|
|
token = serializers.CharField(read_only=True)
|
|
nombre_sistema = serializers.SerializerMethodField() # Agrega estos campos
|
|
rfc_cliente = serializers.SerializerMethodField()
|
|
class Meta:
|
|
model = Sistemas_por_cliente_A24
|
|
fields = ('id_sistema','cliente', 'clienteA24', 'token', 'nombre_sistema', 'rfc_cliente',)
|
|
|
|
def create(self, validated_data):
|
|
cliente = validated_data.get('cliente')
|
|
print('validated_data', validated_data)
|
|
if not cliente:
|
|
|
|
print("context clienteA24 ",self.context.get('clienteA24'))
|
|
print("context DeviceA24 ",self.context.get('DeviceA24'))
|
|
|
|
nuevo_cliente = self.context.get('clienteA24')
|
|
cliente = ClientesA24.objects.create(**nuevo_cliente)
|
|
|
|
sistema_por_cliente = Sistemas_por_cliente_A24.objects.create(
|
|
id_sistema=validated_data['id_sistema'],
|
|
cliente=cliente
|
|
)
|
|
|
|
device_serializer_data = self.context.get('DeviceA24')
|
|
device_serailizer = SerialiazerA24(data=device_serializer_data)
|
|
if device_serailizer.is_valid():
|
|
device = device_serailizer.save()
|
|
sistema_por_cliente.token=device.token
|
|
else:
|
|
sistema_por_cliente.token=""
|
|
|
|
return sistema_por_cliente
|
|
|
|
def get_nombre_sistema(self, obj):
|
|
return obj.id_sistema.nombre_sistema if obj.id_sistema else ""
|
|
|
|
def get_rfc_cliente(self, obj):
|
|
return obj.cliente.RFC if obj.cliente else ""
|
|
|
|
|
|
User = get_user_model()
|
|
class SignupSerializer(serializers.Serializer):
|
|
password = serializers.CharField(write_only=True)
|
|
password2 = serializers.CharField(write_only=True)
|
|
class Meta:
|
|
model = User
|
|
fields = ['username', 'password', 'email', 'first_name', 'last_name']
|
|
def validate(self, data):
|
|
print(f'DATA {data}')
|
|
if data['password'] != data['password2']:
|
|
raise serializers.ValidationError("Las contraseñas no coinciden.")
|
|
return data
|
|
|
|
def create(self, validated_data):
|
|
print(f'CREATE {validated_data}')
|
|
password2 = validated_data.get('password2')
|
|
if password2:
|
|
validated_data.pop('password2')
|
|
|
|
# Asegurarse de tener el campo 'username' en validated_data
|
|
username = self.context['request'].data.get('username')
|
|
email = self.context['request'].data.get('email')
|
|
first_name = self.context['request'].data.get('first_name')
|
|
last_name = self.context['request'].data.get('last_name')
|
|
if not username:
|
|
raise serializers.ValidationError("El campo 'username' es requerido.")
|
|
|
|
# Crear el usuario con los datos validados
|
|
user = User.objects.create_user(username=username, password=validated_data['password'], email=email, first_name=first_name, last_name= last_name)
|
|
# Crea el objeto Email asociado al usuario
|
|
EmailAddress.objects.create(user=user, email=user.email, primary=True, verified=False)
|
|
return user |