def verify_master_user():
print('Iniciando a verificação de usuário Master')
#Instanciando a autenticação da tabela de usuários da api
auth = Authentication(table = 'users_api')
#Verifica se o usuário master existe na tabela de usuários da api
username = '******'
print('Consultando se o usuário master existe')
query = auth.verify_user(username)
print('A consulta retornou ' + str(query))
if query.empty == True:
#Data da criação do usuário
createdAt = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
list_datas = [username, createdAt]
list_labels = ['username','createdAt','password']
#Lendo a senha que foi passada como variável de ambiente
password = os.environ['PASSWORD_MASTER_USER']
print('A senha do usuário Master que foi passada é: ' + password)
try:
print('Inserindo no banco de dados o usuário Master')
#Inserindo o usuário master
auth.insert_new_user(username_json = username,
password_json = password,
list_datas = list_datas,
list_labels = list_labels
)
print('Inserção foi um sucesso')
return 'Successful authentication.'
except Exception as e:
print('Erro na inserção do usuário Master')
raise ValueError(str(e))
def forgot_password():
#Lê o username do usuário que quer ser alterado e os dados do usuário da api
try:
user_api = request.json['user_api']
password_user_api = request.json['password_user_api']
username = request.json['username']
table = request.json['table']
except Exception as e:
raise ValueError('Error: read json. ' + str(e))
try:
#Instancia a classe de autenticação na tabela que o front passar
auth = Authentication(table = table)
auth.authenticate_user(user_api, password_user_api)
except Exception as e:
raise ValueError(str(e))
try:
#Coletando dados desse usuário
query = auth.verify_user(username)
#Coletando email do usuário
email_user = query['email']
#Envia email do usuário
email.send_email(type_message = 'forgot_password',
subject = email_user,
name_addressee = username,
token = '123',
email_address = email_user
)
return 'Successful send email.'
except Exception as e:
raise ValueError('Error: user does not exist. ' + str(e))
def register_user_student():
#Instanciando a autenticação da tabela de estudantes do frontend
auth_users_api = Authentication(table = 'users_api')
auth_users_students = Authentication(table = 'users_students')
try:
user = request.json['user']
username = request.json['username']
password = request.json['password']
name = request.json['name']
registration = request.json['registration']
email = request.json['email']
user_api = request.json['user_api']
password_user_api = request.json['password_user_api']
except Exception as e:
raise ValueError('Error: read json. ' + str(e))
#Data da criação do usuário
createdAt = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
#Verifica se o usuário mestre passado no post é o que permite
#cadastro no banco de dados, se for correto, o cadastro do usuário
#prossegue
try:
auth_users_api.authenticate_user(user_api, password_user_api)
except Exception as e:
raise ValueError(str(e))
list_datas = [username, user, name, registration, email, createdAt]
list_labels = ['username','user', 'name', 'registration', 'email','createdAt','password']
try:
auth_users_students.insert_new_user(username_json = username,
password_json = password,
list_datas = list_datas,
list_labels = list_labels
)
return 'New user student successfully inserted.'
except Exception as e:
raise ValueError(e)
def authenticate_user_teacher():
#Instancia a autenticação na tabela de professores
auth_users_teachers = Authentication(table = 'users_teachers')
try:
username = request.json['username']
password = request.json['password']
except Exception as e:
raise ValueError('Error: read json. ' + str(e))
try:
#Verifica se usuario existe na tabela
auth_users_teachers.authenticate_user(username, password)
return 'Successful authentication.'
except Exception as e:
raise ValueError(str(e))
def update_user():
try:
user_api = request.json['user_api']
password_user_api = request.json['password_user_api']
username = request.json['username']
new_password = request.json['new_password']
table = request.json['table']
except Exception as e:
raise ValueError('Error: read json. ' + str(e))
try:
#Instancia a classe de autenticação na tabela que o front passar
auth = Authentication(table = table)
auth.authenticate_user(user_api, password_user_api)
except Exception as e:
raise ValueError(str(e))
new_password = auth.generate_hash(password)
try:
auth.update_user(table = table,
column_new_data = 'password',
column_reference = 'username',
new_data = username,
data_reference = new_password)
return 'Successful update user.'
except Exception as e:
raise ValueError('Error: update password. ' + str(e))
def post_graphs():
try:
id_class = request.json['id_class']
user_api = request.json['user_api']
password_user_api = request.json['password_user_api']
except Exception as e:
raise ValueError('Error: read json. ' + str(e))
#Verifica se o usuário mestre passado no post é o que permite
#cadastro no banco de dados, se for correto, o cadastro do usuário
#prossegue
try:
auth_users_api = Authentication(table = 'users_api')
auth_users_api.authenticate_user(user_api, password_user_api)
except Exception as e:
raise ValueError(str(e))
#Cria o dataframe com a turma informada
data = pd.DataFrame([id_class], columns = ['id_class'])
try:
condition = "WHERE id_class = '" + data.iloc[0,0] + "'"
df_submission = psql.search(table='submissions', condition = condition)
df_lop_lists = psql.search(table='lists', condition = condition)
df_lop_tests = psql.search(table='tests', condition = condition)
df_question_data = psql.search(table='questions')
df_class = psql.search(table='teachers_classes')
except Exception as e:
raise ValueError('Error: consult at database. ' + str(e))
#Se não tiver nenhuma submissão na turma
if df_submission.empty:
raise ValueError('Error: class without data')
#Selecionando apenas as questões dessa turma
df_questions_selected = lop.select_questions(df_question_data, df_lop_lists, df_lop_tests)
#Dados de lista
try:
#Dados de performance
df_performance_list = lop.performance_list_test(df_submission, 'list', df_lop_lists, df_lop_tests, df_question_data)
df_performance_difficulty_list = lop.performance_difficulty_list_test(df_submission, df_questions_selected,'list')
df_performance_subject_list = lop.performance_subject_list_test(df_submission, df_questions_selected, 'list')
#Grafico 1, desempenho por turma analisando notas
GENL = lop.graph_more_less_list_test_class(df_performance_list, df_class, data, 70.0, 'list')
GTDL = lop.graph_more_less_difficulty_list_test_class(df_performance_difficulty_list, df_class, data, 70.0)
GTAL = lop.graph_more_less_subject_list_test_class(df_performance_subject_list, df_class, data, 70.0)
#Grafico 2, desempenho por aluno analisando notas
GTNL = lop.graph_performance_student_list_test(df_performance_list, df_class, data, 'list')
GEDL = lop.graph_performance_student_difficulty_list_test(df_performance_difficulty_list, df_class, data)
GEAL = lop.graph_performance_student_subject_list_test(df_performance_subject_list, data, df_class)
#Média geral dos alunos
media_GTNL = lop.media_graph_performance_student_list_test(df_performance_list, df_questions_selected, 'list')
media_GEDL = lop.media_graph_performance_student_difficulty_list_test(df_performance_difficulty_list, df_questions_selected)
media_GEAL = lop.media_graph_performance_subject_list_test(df_performance_subject_list)
except Exception as e:
raise ValueError('Error: generate data lists. ' + str(e))
#Se não tiver nenhuma prova cadastrada
if df_lop_tests.empty:
#Insere vazio e não realiza a geração dos dados
try:
#Grafico 1, desempenho por turma analisando notas
GENP = json.dumps([{}])
GTDP = json.dumps([{}])
GTAP = json.dumps([{}])
#Grafico 2, desempenho por aluno analisando notas
GTNP = json.dumps([{}])
GEDP = json.dumps([{}])
GEAP = json.dumps([{}])
#Média geral dos alunos
media_GTNP = json.dumps([{}])
media_GEDP = json.dumps([{}])
media_GEAP = json.dumps([{}])
except:
raise ValueError('Error: insert empty in data tests')
#Se existe provas cadastradas, gera os dados normalmente
else:
try:
df_performance_test = lop.performance_list_test(df_submission, 'test', df_lop_lists, df_lop_tests, df_question_data)
df_performance_difficulty_test = lop.performance_difficulty_list_test(df_submission, df_questions_selected,'test')
df_performance_subject_test = lop.performance_subject_list_test(df_submission, df_questions_selected, 'test')
#Grafico 1, desempenho por turma analisando notas
GENP = lop.graph_more_less_list_test_class(df_performance_test, df_class, data, 70.0, 'test')
GTDP = lop.graph_more_less_difficulty_list_test_class(df_performance_difficulty_test, df_class, data, 70.0)
GTAP = lop.graph_more_less_subject_list_test_class(df_performance_subject_test, df_class, data, 70.0)
#Grafico 2, desempenho por aluno analisando notas
GTNP = lop.graph_performance_student_list_test(df_performance_test, df_class, data, 'test')
GEDP = lop.graph_performance_student_difficulty_list_test(df_performance_difficulty_test, df_class, data)
GEAP = lop.graph_performance_student_subject_list_test(df_performance_subject_test, data, df_class)
#Média geral dos alunos
media_GTNP = lop.media_graph_performance_student_list_test(df_performance_test, df_questions_selected, 'test')
media_GEDP = lop.media_graph_performance_student_difficulty_list_test(df_performance_difficulty_test, df_questions_selected)
media_GEAP = lop.media_graph_performance_subject_list_test(df_performance_subject_test)
except:
raise ValueError('Error: generate data tests')
#Histograma do dias gastos para concluir uma lista/assunto/dificuldade
try:
GTDGL = lop.graph_days_spent_list(df_submission)
GTDGA = lop.graph_days_spent_subject(df_submission, df_questions_selected)
GTDGD = lop.graph_days_spent_difficulty(df_submission, df_questions_selected)
except:
raise ValueError('Error: generate graph days spent per list/subject/difficulty')
#Transformando em um só json
name_graphs = ['"GENL"','"GENP"','"GTDL"','"GTDP"','"GTAL"','"GTAP"',
'"GTNL"','"GTNP"','"GEDL"','"GEDP"','"GEAL"','"GEAP"',
'"media_GTNL"','"media_GTNP"','"media_GEDL"','"media_GEDP"','"media_GEAL"','"media_GEAP"',
'"GTDGL"','"GTDGA"','"GTDGD"']
graphs = [GENL,GENP,GTDL,GTDP,GTAL,GTAP,
GTNL,GTNP,GEDL,GEDP,GEAL,GEAP,
media_GTNL,media_GTNP,media_GEDL,media_GEDP,media_GEAL,media_GEAP,
GTDGL,GTDGA,GTDGD]
return lop.create_unique_json(name_graphs, graphs)