def generic_verify(query):
try:
obj = query()
if obj.check_password(password):
context = UserSerializer(obj).data
if obj.tipo_user == "Professor":
context['typeId'] = ProfessorSerializer(
Professor.objects.get(user=obj)).data.get("id")
else:
context['typeId'] = AlunoSerializer(
Aluno.objects.get(user=obj)).data.get("id")
context['perfilPhoto'] = AlunoSerializer(
Aluno.objects.get(
user=obj)).data.get("perfilPhoto")
return Response({'status': True, 'user': context})
else:
return Response({
'status': False,
'error': 'Senha incorreta.'
})
except ObjectDoesNotExist as ex:
print(ex)
return generic_except(ex)
except Exception as ex:
generic_except(ex)
def update(self, request, *args, **kwargs):
try:
id_aula = kwargs['pk']
data: dict = request.data
aula = Aula.objects.get(id=id_aula)
if data.__contains__('tipo') and data['tipo'] is not None:
tipo = unidecode.unidecode(data['tipo'].lower())
else:
tipo = None
aula_tipo = unidecode.unidecode(
aula.tipo_aula.lower() if aula.tipo_aula is not None else '')
if aula.tipo_aula != tipo:
if aula.tipo_aula is not None:
self.TYPE_OBJ[aula_tipo].objects.get(aula=aula).delete()
aula.tipo_aula = tipo
self.createTypeObj(aula, data['extra'], tipo)
elif aula.tipo_aula is not None:
self.checkExtra(aula, data['extra'], tipo)
aula.tema = data['tema']
aula.is_assincrona = data['is_assincrona']
aula.descricao = data['descricao']
aula.link_documento = data['link']
if aula.is_assincrona:
aula.end_time = dateutil.parser.parse(data['end_time'])
aula.save()
return Response({'status': True})
except Exception as ex:
return generic_except(ex)
def retrieve(self, request: Request, *args, **kwargs):
try:
id = kwargs['pk']
topicos = TopicaTurma.objects.filter(turma_id=id)
return Response({"status": True, 'topicos': self.serializer_class(topicos, many=True).data})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
data: dict = request.data
try:
if data.__contains__('avaliacaoId') and data.__contains__(
'perguntaId'):
tipo = data['tipo_resposta']
resp = data['resposta']
aval = Avaliacao.objects.get(id=data['avaliacaoId'])
pergunta = Pergunta.objects.get(id=data['perguntaId'])
resp_obj = Resposta(
tipo_resposta=tipo,
avaliacao=aval,
avaliacao_aula=aval.aula,
avaliacao_aluno=aval.aluno,
pergunta=pergunta,
)
if tipo == 'binario':
resp_obj.resposta_binario = resp
elif tipo == 'qualificativa':
resp_obj.resposta_qualificativa = resp
elif tipo == 'aberta':
resp_obj.resposta_aberta = resp
resp_obj.save()
# Caso seja a ultima resposta de uma avaliação
if data.__contains__('end'):
aval.end_time = timezone.now()
aval.completa = True
if aval.aula.is_assincrona is False:
aval.pontos = decimal.Decimal(
CalcAvalPontuacao(aval.aula.end_time,
aval.end_time))
else:
aval.pontos = 25
aval.save()
aluno_turma = AlunoHasTurma.objects.get(
aluno=aval.aluno, turma=aval.aula.turma)
aluno_turma.xp += aval.pontos
aluno_turma.save()
if aval.aula.is_assincrona is False:
aluno = Aluno.objects.get(id=aval.aluno.id)
aluno.xp += aluno_turma.xp
aluno.save()
return Response({'status': True})
else:
return Response({
'status': False,
'error': 'Something is missing 👀'
})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
data: dict = request.data
try:
if data.__contains__("idTurma") and data.__contains__("schedules"):
turma = Turma.objects.get(id=data["idTurma"])
scheduleReceived: list = data['schedules']
for i in scheduleReceived:
if i.__contains__('id'):
if i['id']:
if i['id'] > 0:
# Editando
dia = DiasFixos.objects.get(id=i['id'], turma_id=turma.id)
if i['horario'] is not None:
newTime = dateutil.parser.parse(i['horario'])
date1 = datetime(dia.horario.year, dia.horario.month, dia.horario.day,
dia.horario.hour,
dia.horario.minute)
date2 = datetime(newTime.year, newTime.month, newTime.day, newTime.hour,
newTime.minute)
if date1 != date2 or dia.sala != i['sala']:
aulas = Aula.objects.filter(turma=turma,
sala=dia.sala,
dia_horario__hour=dia.horario.hour,
dia_horario__minute=dia.horario.minute)
dia.horario = newTime
dia.sala = i['sala']
for aula in aulas:
aula.dia_horario = datetime(aula.dia_horario.year, aula.dia_horario.month,
aula.dia_horario.day, newTime.hour,
newTime.minute)
aula.sala = dia.sala
aula.save()
dia.save(edit=True)
else:
# Deletando
dia.delete()
elif i['id'] < 0:
# Lixo de memoria
# Esse Dia provavelmente já foi salvo no BD e está vindo alguma requisição que não foi atualizada no front
pass
else:
# Criando
dia = DiasFixos(
turma=turma,
dia=dayToEnum(i['dia'][0:3]),
horario=dateutil.parser.parse(i['horario']),
sala=i['sala']
)
dia.save()
else:
Response({"status": False, "error": "Algo está faltando"})
return Response({"status": True})
else:
return Response({"status": False, "error": "Algo está faltando"})
except Exception as ex:
return generic_except(ex)
def put_class_end(request):
try:
aula = Aula.objects.get(id=request.data['id'])
aula.is_aberta_avaliacao = True
aula.is_aberta_class = False
diferenca = timezone('America/Sao_Paulo')
aula.end_time = datetime.now().astimezone(diferenca)
aula.save()
return Response({'status': True})
except Exception as ex:
return generic_except(ex)
def retrieve(self, request, *args, **kwargs):
try:
if request.user.tipo_user == 'Professor':
sug = SugestaoTurma.objects.filter(turma=kwargs['pk'])
else:
aluno = Aluno.objects.get(user=request.user)
sug = SugestaoTurma.objects.filter(turma=kwargs['pk'], aluno=aluno)
sug = sug.order_by('-data')
return Response({"status": True,
'suguestoes': self.serializer_class(sug, many=True).data})
except Exception as ex:
return generic_except(ex)
def pupils_list(request: Request, id: int):
try:
alunos = []
try:
alunos_turma = AlunoHasTurma.objects.filter(turma_id=id)
except ObjectDoesNotExist as ex:
print(">>> Wasn't Possible find the Turma")
return Response({"status": False, "message": "Não foi possivel achar a turma"})
for i in alunos_turma:
alunos.append(i.aluno)
return Response({"status": True, "alunos": AlunoSerializer(alunos, many=True).data})
except Exception as ex:
return generic_except(ex)
def destroy(self, request: Request, *args, **kwargs):
try:
id_aula = kwargs['pk']
aula = Aula.objects.get(id=id_aula)
if aula.tipo_aula == 'teorica':
Teorica.objects.get(aula=aula).delete()
elif aula.tipo_aula == 'prova':
Prova.objects.get(aula=aula).delete()
elif aula.tipo_aula == 'trabalho':
TrabalhoPratico.objects.get(aula=aula).delete()
elif aula.tipo_aula == 'excursao':
Excursao.objects.get(aula=aula).delete()
aula.delete()
return Response({'status': True})
except Exception as ex:
return generic_except(ex)
def update(self, request, *args, **kwargs):
try:
id = kwargs['pk']
data = request.data
turma = Faculdade.objects.get(id=id)
for i in data:
if int(i['id']) >= 0:
topico = TopicoFaculdade.objects.get(id=i['id'])
if not topico.topico == i['topico']:
topico.topico = i['topico']
topico.save()
else:
TopicoFaculdade(topico=i['topico'], turma=turma).save()
return Response({"status": True})
except Exception as ex:
return generic_except(ex)
def update(self, request, *args, **kwargs):
try:
id = kwargs['pk']
print(id)
data = request.data
curso = Curso.objects.get(id=id)
for i in data:
if int(i['id']) >= 0:
topico = TopicoSugestaoCurso.objects.get(id=i['id'])
if not topico.topico == i['topico']:
topico.topico = i['topico']
topico.save()
else:
TopicoSugestaoCurso(topico=i['topico'], curso=curso).save()
return Response({"status": True})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
data: dict = request.data
try:
if data.__contains__('aulaId'):
aula = Aula.objects.get(id=data['aulaId'])
token = Token.objects.get(key=request.auth)
user = User.objects.get(pk=token.user.pk)
aluno = Aluno.objects.get(user=user)
resp = None
try:
aval = Avaliacao.objects.get(aula=aula, aluno=aluno)
resp = Resposta.objects.filter(avaliacao=aval)
print(resp)
except Exception as ex:
aval = Avaliacao(
aula=aula,
aluno=aluno,
completa=False,
)
aval.save()
context = {'avaliacao': self.serializer_class(aval).data}
context['avaliacao']['tipo_aula'] = aula.tipo_aula
perguntas: QuerySet = Pergunta.objects.filter(
tipo_aula=aula.tipo_aula)
if resp is not None:
for i in resp:
perguntas = perguntas.exclude(id=i.pergunta.id)
context['avaliacao']['perguntas'] = PerguntaSerializer(
perguntas, many=True).data
for i in context['avaliacao']['perguntas']:
i['caracteristica'] = i['caracteristica']['qualificacao']
print(context)
return Response({'status': True, **context})
else:
return Response({
'status': False,
'error': 'Something is missing 👀'
})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
try:
data = request.data
user = User(
nome=data['name'],
username=User.normalize_username(data['user']),
matricula=data['matricula'],
email=User.normalize_email(data['email']),
tipo_user=data['tipo_user'],
)
validate_password(data['pass'])
user.set_password(data['pass'])
user.save()
context = UserSerializer(user).data
if data['tipo_user'] == 1:
prof = Professor(
lattes=data.get('lattes'),
user=user,
)
prof.save()
context['prof_id'] = prof.pk
else:
try:
curso = Curso.objects.get(id=data.get('curso'))
except ObjectDoesNotExist as ex:
curso = None
aluno = Aluno(xp=0, curso_idcurso=curso, user=user)
aluno.save()
context['prof_id'] = aluno.pk
# context['token'] = Token.objects.get(user=user).key
return Response({'status': True, 'user': context})
except IntegrityError as ex:
return verf_user_integrityerror(ex)
except ValidationError:
return Response({
'status':
False,
'error':
"Sua senha é muito simples. Dicas: Ela tem que ter mais de 8 digitos e não pode conter só numeros"
})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
data: dict = request.data
try:
if 'sugestao' in data and 'titulo' in data:
aluno = Aluno.objects.get(user=request.user)
topico: TopicaTurma = TopicaTurma.objects.get(id=data['topico'])
SugestaoTurma(
sugestao=data['sugestao'],
titulo=data['titulo'],
data=datetime.today(),
topico=topico,
turma=topico.turma,
aluno=aluno
).save()
else:
return Response({'status': False, 'error': 'Something is missing 👀'})
return Response({'status': True})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
data: dict = request.data
try:
if data.__contains__('turmaId'):
turma = Turma.objects.get(id=data['turmaId'])
aula = Aula(dia_horario=dateutil.parser.parse(data['time']),
sala=data['room'],
is_aberta_class=0,
is_aberta_avaliacao=0,
turma=turma)
aula.save()
return Response({
'status': True,
'aula': AulaSerializer(aula).data
})
else:
return Response({
'status': False,
'error': 'Something is missing 👀'
})
except Exception as ex:
return generic_except(ex)
def create(self, request, *args, **kwargs):
try:
data = request.data
try:
prof = Professor.objects.get(id=data.get('prof'))
except ObjectDoesNotExist as ex:
prof = None
try:
facu = Faculdade.objects.get(id=data.get('facu'))
except ObjectDoesNotExist as ex:
facu = None
curso = Curso(
nome=data['name'],
codigo=data['codigo'],
faculdade=facu,
professor_coordenador=prof,
)
curso.save()
serializer_context = {
'request': request,
}
return Response({
'status':
True,
'curso':
CursoSerializer(curso, context=serializer_context).data
})
except IntegrityError as ex:
return Response({
'status': False,
'error': "Algum campo está faltando.",
'except': ex.args
})
except Exception as ex:
return generic_except(ex)
def create(self, request):
data = request.data
try:
login = data['login']
password = data['pass']
print(data)
def generic_verify(query):
try:
obj = query()
if obj.check_password(password):
context = UserSerializer(obj).data
if obj.tipo_user == "Professor":
context['typeId'] = ProfessorSerializer(
Professor.objects.get(user=obj)).data.get("id")
else:
context['typeId'] = AlunoSerializer(
Aluno.objects.get(user=obj)).data.get("id")
context['perfilPhoto'] = AlunoSerializer(
Aluno.objects.get(
user=obj)).data.get("perfilPhoto")
return Response({'status': True, 'user': context})
else:
return Response({
'status': False,
'error': 'Senha incorreta.'
})
except ObjectDoesNotExist as ex:
print(ex)
return generic_except(ex)
except Exception as ex:
generic_except(ex)
def verify_email():
return generic_verify(lambda: User.objects.get(email=login))
def verify_user_name():
return generic_verify(lambda: User.objects.get(username=login))
def verify_matricula():
return generic_verify(
lambda: User.objects.get(matricula=login))
if '@' in login:
resp = verify_email()
if resp:
return resp
return Response({
'status': False,
'error': 'Nenhum email correspondente.'
})
elif re.search(r'\d+', login):
resp = verify_matricula()
if resp:
return resp
return Response({
'status': False,
'error': 'Nenhuma matricula correspondente.'
})
else:
resp = verify_user_name()
if resp:
return resp
return Response({
'status': False,
'error': 'Nenhum username correspondente.'
})
except Exception as ex:
return generic_except(ex)
def destroy(self, request, *args, **kwargs):
try:
TopicoSugestaoCurso.objects.get(id=kwargs['pk']).delete()
return Response({"status": True})
except Exception as ex:
return generic_except(ex)
