Ejemplo n.º 1
0
def get_model_by(data_model, **kwargs, ):
    error_message = kwargs.pop('error_message')
    serializer = kwargs.pop('serializer')
    response = kwargs.pop('response')
    respuesta = dict()
    try:

        model = data_model.objects.get(**kwargs)
        respuesta['model'] = model
        if serializer is not None:
            respuesta['model_serialized'] = serializer(model)

            if response:
                respuesta['response'] = CustomResponse.success(respuesta['model_serialized'].data)

    except data_model.DoesNotExist:
        if error_message is None:
            error_message = 'NO SE HAN ENCONTRADO VALORES'
        return dict(
            has_error=True,
            message=error_message,
            response=CustomResponse.error(error_message)
        )
    else:
        return respuesta
Ejemplo n.º 2
0
def get_tareas(request, identificacion, *args, **kwargs):
    if identificacion is not None:
        alumno = Alumno.objects.filter(persona__identificacion=identificacion).first()
        docente = Personal.objects.filter(persona__identificacion=identificacion).first()

        if alumno or docente is not None:
            serializer = TareaSerializer
            if alumno is not None:
                tareas = Tarea.objects.filter(alumnos__contains=[
                    {
                        'identificacion': identificacion
                    }
                ])

            else:
                tareas = Tarea.objects.filter(docente__contains={
                    'identificacion': identificacion
                })

            # Query params
            estado_envio = request.data.get('estado_envio', None)
            if estado_envio is not None:
                tareas = tareas.filter(estado_envio=estado_envio)

            tarea_serialized = serializer(tareas, many=True)
            return CustomResponse.success(tarea_serialized.data)

        else:
            return CustomResponse.error(
                'POR FAVOR VERIFIQUE LA IDENTIFICACION ENVIADA, NO SE HAN ENCONTRADO RESULTADOS')

    return CustomResponse.error(mensaje='NO SE HA ENVIADO UNA IDENTIFICACION')
Ejemplo n.º 3
0
def is_docente_or_alumno(identificacion, error_msg="NO SE HAN ENCONTRADO RESULTADOS"):
    if identificacion is None and identificacion != "":
        error_message = "NO SE HA PROPORCIONADO UNA IDENTIFICACION"
        return dict(
            has_error=True,
            message=error_message,
            response_error=CustomResponse.error(error_message)
        )

    alumno = Alumno.objects.filter(persona__identificacion=identificacion).first()

    docente = Personal.objects.filter(
        persona__identificacion=identificacion,
        funciones__codigo=FuncionPersonal.DOCENTE
    ).first()

    if alumno is None and docente is None:
        return dict(
            has_error=True,
            message=error_msg,
            response_error=CustomResponse.error(error_msg)
        )
    is_alumno = False
    is_docente = False
    if alumno is not None:
        is_alumno = True
        return dict(rol="ALUMNO", data=alumno, is_alumno=is_alumno, is_docente=is_docente)

    is_docente = True
    return dict(rol="DOCENTE", data=docente, is_alumno=is_alumno, is_docente=is_docente)
Ejemplo n.º 4
0
def crear_lista_reproduccion(request: Request, *args, **kwargs):
    lista_serializer = ListaReproduccionSerializer(data=request.data)
    if lista_serializer.is_valid():
        lista = lista_serializer.create(request.data)
        lista.save()
        return CustomResponse.success(ListaReproduccionSerializer(lista).data)
    return CustomResponse.error('ENVIE INFORMACION VALIDA', extra_info=lista_serializer.errors)
Ejemplo n.º 5
0
def create_tarea(request: Request, *args, **kwargs):
    tarea_serializer = TareaSerializer(data=request.data)
    if tarea_serializer.is_valid():
        tarea = tarea_serializer.create(request.data)
        tarea.save()
        return CustomResponse.success(TareaSerializer(tarea).data)
    return CustomResponse.error('ENVIE INFORMACION VALIDA')
Ejemplo n.º 6
0
def login(request: Request, *args, **kwargs):
    data: dict = request.data
    message_bytes = base64.b64decode(data.get('password', ''))
    password = message_bytes.decode('utf-8')
    password = password.replace('"', "")
    user: Usuario = authenticate(username=data.get('username', ''), password=password)
    if user is not None:

        group = Group.objects.get(name="MLN")
        # push = PushInformation.objects.filter(user=user, group=group, ).first()
        #
        # if push is None:
        p256dh = data.get('p_256dh')
        subscription_information = SubscriptionInfo(
            browser=data.get('browser'),
            endpoint=data.get('endpoint'),
            auth=data.get('auth'),
            p256dh=p256dh
        )
        subscription_information.save()

        push_info = PushInformation(user=user, group=group, subscription=subscription_information)
        push_info.save()

        identificacion = user.persona.identificacion
        result = is_docente_or_alumno(
            identificacion,
            error_msg="No se han encontrado resultados de algun usuario DOCENTE o ALUMNO con esas credenciales"
        )

        if result.get('has_error', False):
            return result.get('response_error')
        return UsuarioQueries.get_info_usuario_response(identificacion)

    return CustomResponse.error('No se ha encontrado ningun usuario con esas credenciales')
Ejemplo n.º 7
0
def get_listas_reproduccion(request: Request, *args, **kwargs):
    queries = request.data.get('queries', None)

    if queries is None or queries is not None and queries.get('auth_estado') is None:
        queries = dict(auth_estado='A')

    listas = ListaReproduccion.objects.filter(**queries)
    listas_serialized = ListaReproduccionSerializer(listas, many=True)
    return CustomResponse.success(listas_serialized.data)
Ejemplo n.º 8
0
def tarea_by_id(request: Request, id, is_docente, *args, **kwargs):
    if request.method == 'GET':
        tarea = Tarea.objects.filter(pk=id).first()
        tarea_serialized = TareaSerializer(tarea)
        return CustomResponse.success(tarea_serialized.data)

    tarea = Tarea.objects.get(pk=id)
    serialized_tarea = TareaSerializer(tarea)
    tarea = serialized_tarea.update(tarea, request.data)
    tarea.save()
    if is_docente:
        if tarea.estado_envio == "ENVIADO" and tarea.alumnos is not None:
            for alumno in tarea.alumnos:
                usuario = Usuario.objects.filter(persona__id=alumno.get('id_persona')).first()
                notificar_tarea_enviada(
                    head="NUEVA TAREA",
                    body=f'Tu docente "{tarea.docente.get("str")}"',
                    id_usuario=usuario.pk
                )

    return CustomResponse.success(TareaSerializer(tarea).data)
Ejemplo n.º 9
0
def editar_lista_reproduccion_by_id(request: Request, id: int, *args, **kwargs):
    respuesta = get_model_by(
        ListaReproduccion,
        error_message='NO SE HA ENCONTRADO UNA LISTA DE REPRODUCCION CON ESE ID',
        serializer=ListaReproduccionSerializer,
        response=True,
        id=id,
    )

    if respuesta.get('has_error'):
        return respuesta.get('response')
    lista_serd = ListaReproduccionSerializer(data=request.data)

    if lista_serd.is_valid():
        lista: ListaReproduccion = respuesta.get('model')
        lista_serialized: ListaReproduccionSerializer = respuesta.get('model_serialized')

        lista_updated = lista_serialized.update(lista, request.data)
        lista_updated.save()

        return CustomResponse.success_message(ListaReproduccionSerializer(lista_updated).data)
    return CustomResponse.error('LA INFORMACION ENVIADA NO ES VALIDA', extra_info=lista_serd.errors)
Ejemplo n.º 10
0
def logout(request: Request, *args, **kwargs):
    try:
        data: dict = request.data

        username = data.get('username', None)
        push_info: dict = data.get('push_info', None)

        if username is not None and push_info is not None:
            subscription = SubscriptionInfo.objects.filter(
                browser=push_info.get("browser", None),
                endpoint=push_info.get("endpoint", None),
                auth=push_info.get("auth", None),
                p256dh=push_info.get("p_256dh", None)
            ).first()
            push_info = PushInformation.objects.filter(
                user=Usuario.objects.get(username=username),
                subscription=subscription
            )
            push_info.delete()
            subscription.delete()
            return CustomResponse.success()
    except:
        return CustomResponse.error('Ha ocurrido un problema al momento de realizar el logout')
Ejemplo n.º 11
0
def eliminar_lista_reproduccion_by_id(request: Request, id: int, *args, **kwargs):
    respuesta = get_model_by(
        ListaReproduccion,
        error_message='NO SE HA ENCONTRADO UNA LISTA DE REPRODUCCION CON ESE ID',
        serializer=ListaReproduccionSerializer,
        response=True,
        id=id,
    )

    if respuesta.get('has_error'):
        return respuesta.get('response')

    lista: ListaReproduccion = respuesta.get('model')
    lista.auth_estado = AUTH_ESTADOS['INACTIVO']
    lista.save()
    return CustomResponse.success_message('SE HA ELIMINADO CORRECTAMENTE LA LISTA DE REPRODUCCION')
Ejemplo n.º 12
0
    def get_info_usuario_response(identificacion=''):

        data = is_docente_or_alumno(identificacion)

        if data.get('error', None) is not None:
            return data.get('response_error')

        rol = data.get('rol')
        data_docente_alumno = data.pop('data')

        if rol == "ALUMNO":
            alumno_serialized = AlumnoSerializer(data_docente_alumno)
            data['is_docente'] = False
            data['is_alumno'] = True
            data.update(alumno_serialized.data)

        else:
            data['is_docente'] = True
            data['is_alumno'] = False
            docente_serialized = DocenteSerializer(data_docente_alumno)
            data.update(docente_serialized.data)

        return CustomResponse.success(data)
Ejemplo n.º 13
0
def delete_tarea(request: Request, id: int, *args, **kwargs):
    tarea = Tarea.objects.filter(pk=id).first()
    if tarea is not None:
        tarea.delete()
    return CustomResponse.success('SE HA ELIMINADO CORRECTAMENTE')