def cadastrar():
data = request.get_json()
if data['email'] and data['senha']:
try:
user = Usuario.query.filter_by(email=data['email']).first()
except Exception as e:
print(e)
return bad_request(403, 'Não possui usuario com esse email')
check_senha = Cadastro(senha=user.cadastro_usuario[0].senha)
if user is None or not check_senha.check(data['senha']):
return bad_request(403, 'usuario e/ou senha errado')
token = generate_token(user)
return jsonify({
'message':
'usuario {} autenticado com sucesso '.format(str(user.nome)),
'user':
str(user.nome),
'success':
1,
'token':
token
})
return bad_request(403, 'não foi informado credenciais para login')
def new_user():
data = request.get_json()
if 'nome' not in data or 'email' not in data or 'senha' not in data or 'tag_id' not in data:
return bad_request(403, 'Precisa passar nome, email,senha e tag')
if Usuario.query.filter_by(nome=data['nome']).first():
return bad_request(403, 'Use um outro nome')
if Usuario.query.filter_by(email=data['email']).first():
return bad_request(403, 'Use um outro email')
data['ativo'] = 'S'
usuario = Usuario()
usuario.from_dict(data)
cadastro = Cadastro()
cadastro.passwd(data['senha'])
usuario.cadastro_usuario = [cadastro]
db.session.add(usuario)
db.session.add(cadastro)
db.session.commit()
message = {'message': 'usuario criado'}
return jsonify(message), 200
def get_usuario_token():
try:
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
# users = Usuario.query.filter_by(id_usuario = user_id)
users = Usuario.query.join(Funcao,Usuario.funcao_id == Funcao.id_funcao)\
.join(Acesso,Usuario.acesso_id == Acesso.id_acesso)\
.join(Tag,Tag.id_tag == Usuario.tag_id)\
.add_columns(Usuario.id_usuario,Usuario.nome,Tag.tag,Funcao.descricao,Acesso.descricao,Usuario.email)\
.filter(Usuario.id_usuario == user_id)\
.first()
response = {
'id_usuario': users[1],
'nome': users[2],
'tag': users[3],
'funcao': users[4],
'acesso': users[5],
'email': users[6]
}
return response, 200
except Exception as e:
return bad_request(404, 'Não foi possivel trazer as informações')
def status_sala_limpeza():
try:
with db.engine.connect() as conn:
query = text("""
select salas.id_sala as sala_id,salas.numero,sala_status.limpeza as limpa
from sala_status
join salas on
sala_status.sala_id = salas.id_sala
where sala_status.limpeza = '1'
""")
result = conn.execute(query).fetchall()
message = {
'salas': [{column: value
for column, value in rowproxy.items()}
for rowproxy in result]
}
# print(message)
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'não foi possivel realizar a consulta')
def qr_code():
try:
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
pedidos = Envio.query.join(Pedido,Pedido.cod_pedido == Envio.codigo_pedido) \
.filter(Pedido.usuario_id == user_id) \
.add_columns(Pedido.usuario_id,Envio.codigo_envio,Envio.qr_code,Envio.codigo_pedido,Envio.token) \
.all()
items = []
for row in pedidos:
items.append({
'id_usuario': row[1],
'codigo_envio': row[2],
'qr_code': row[3],
"codigo_pedido": row[4],
"token": row[5]
})
# print(items)
message = {'items': items}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel trazer usuario')
def get_agendamento():
try:
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
dia_futuro = dia + timedelta(days=7)
agend = A.query.join(S,S.id_sala == A.sala_id ) \
.join(ST,ST.sala_tipo_id == S.sala_tipo_id) \
.add_columns(A.id_agendamento, A.data, A.horario_inicio, A.horario_final, S.id_sala, S.numero, ST.descricao) \
.filter(A.usuario_id == user_id,A.data.between(dia,dia_futuro)) \
.all()
items = []
for row in agend:
items.append({
'id_agendamento':row[1],
'data': str(row[2]),
'horario_inicio': str(row[3]),
'horario_final': str(row[4]),
'id_sala':row[5],
'numero':row[6],
'tipo_sala':row[7]
})
message = {
'items': items
}
return jsonify(message),200
except Exception as e:
print(e)
return bad_request(403,'não foi possivel carregar o agendamento')
def get_usuario():
try:
users = Usuario.query.join(Tag,Tag.id_tag == Usuario.tag_id) \
.join(Acesso,Acesso.id_acesso == Usuario.acesso_id) \
.join(Funcao,Funcao.id_funcao == Usuario.funcao_id) \
.filter(Usuario.ativo == 'S') \
.add_columns(Usuario.id_usuario,Usuario.nome,Usuario.email,Tag.tag,Tag.id_tag,Acesso.id_acesso,Acesso.descricao,Funcao.id_funcao,Funcao.descricao) \
.all()
items = []
for row in users:
items.append({
'id_usuario': row[1],
'nome': row[2],
'email': row[3],
'tag': row[4],
'tag_id': row[5],
'acesso_id': row[6],
'acesso': row[7],
'funcao_id': row[8],
'funcao': row[9]
})
message = {'items': items}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel trazer usuario')
def envio():
try:
def generate_uuid():
id = uuid.uuid4()
return id.hex
data = request.get_json()
data['codigo_envio'] = generate_uuid()
data['token'] = generate_uuid()
data['codigo_pedido'] = data['cod_pedido']
data['usuario_id'] = data['id_usuario']
# print(data)
qrcode_ = make_qr_code(json.dumps(data))
data['qr_code'] = qrcode_
envio_ = Envio()
# print(envio_.__table__.columns)
envio_.from_dict(data)
db.session.add(envio_)
db.session.commit()
message = {'message': 'Envio criado'}
return jsonify(message), 201
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel trazer usuario')
def get_sala_tipo():
try:
salas_tipo = SalasTipo.query.all()
message = {'items': [item.to_dict() for item in salas_tipo]}
return jsonify(message), 200
except Exception as identifier:
return bad_request(
403, 'Nao foi possivel trazer a lista de tipos de salas')
def reset_pass():
token = request.headers.get('x-access-token')
data = request.get_json()
if int(data.get('nova_senha')):
verify_token = decode_token(token)
user_id = verify_token['id_user']
else:
user_id = data['id_usuario']
try:
user = Usuario.query.filter_by(id_usuario=user_id).first()
except Exception as e:
return bad_request(403, 'Não possui usuario com esse email')
if int(data.get('nova_senha')):
try:
check_senha = Cadastro(senha=user.cadastro_usuario[0].senha)
if user is None or not check_senha.check(data['senha']):
return jsonify({
'message': 'usuario e/ou senha errado',
'succes': 0
}), 403
except Exception as identifier:
return bad_request(403, 'Senhas não coincidem')
if data.get('senha_nova') and data.get('senha_confirma'):
if data['senha_nova'] != data['senha_confirma']:
return bad_request(403, 'Senhas não conferem')
try:
new_cadastro = user.cadastro_usuario[0].to_dict()
cadastro = Cadastro()
cadastro.from_dict(new_cadastro)
cadastro.passwd(data['senha_nova'])
user.cadastro_usuario[0].senha = cadastro.senha
db.session.commit()
except Exception as identifier:
return bad_request(403, 'Não foi possivel alterar a sennha')
return jsonify({'message': 'senha alterada com sucesso'}), 200
def agendamento(tag):
try:
data = datetime.datetime.today() - datetime.timedelta(hours=3)
hora = str(data.hour) + ':' + str(data.minute) + ':' + '00'
hora_atual = datetime.time(hour=data.hour,
minute=data.minute,
second=0)
data_atual = str(data.year) + '-' + str(data.month) + '-' + str(
data.day)
usuario = Usuario.query.join(Tag,Tag.id_tag == Usuario.tag_id)\
.add_columns(Usuario.id_usuario,Tag.id_tag,Usuario.funcao_id) \
.filter(Tag.tag == tag) \
.first()
agendamento = Agendamento.query.join(Usuario,Usuario.id_usuario == Agendamento.usuario_id) \
.join(Tag,Tag.id_tag == Usuario.tag_id)\
.add_columns(Agendamento.horario_inicio,Agendamento.horario_final,Agendamento.id_agendamento)\
.filter(Usuario.id_usuario == usuario[1],Agendamento.data == data_atual)\
.all()
items = []
if usuario[3] == 3:
items.append({'acesso': 3})
if usuario[3] == 2:
items.append({'acesso': 2})
for row in agendamento:
horas_resultado = datetime.datetime.combine(
datetime.date.today(), row[1])
# print(horas_resultado.time())
# print(hora_atual)
# print(row)
if usuario[3] == 1:
horas_delta = horas_resultado - datetime.timedelta(minutes=15)
if hora_atual == horas_delta.time() or hora_atual <= row[2]:
items.append({
'horario_inicio': str(horas_delta.time()),
'horario_final': str(row[2]),
'acesso': 1,
'id_agendamento': str(row[3])
})
# print(items)
message = {'items': items}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'nao foi possivel trazer o agendamento')
def func_all():
try:
users = Usuario.query.count()
message = {'usuarios': users}
return jsonify(message), 200
except Exception:
return bad_request(403, 'Não foi possivel encontrar usuário')
def sala_disponivel():
try:
salas = Salas.query.count()
message = {'salas': salas}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'não foi possivel realizar a consulta')
def func_limpeza():
try:
salas = SalasStatus.query.filter(SalasStatus.limpeza == '1') \
.count()
message = {'salas': salas}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel encontrar usuário')
def new_sala():
try:
data = request.get_json()
data['quantidade'] = int(data['quantidade'])
sala = Salas()
sala.from_dict(data)
db.session.add(sala)
db.session.commit()
return jsonify({'message': 'Sala adicionada com sucesso'}), 200
except Exception as identifier:
print(identifier)
return bad_request(403, 'Nao foi possivel inserir sala')
def delete_agendamento():
try:
data = request.get_json()
delet_agendamento = A.query.filter_by(id_agendamento=data['id_agendamento']).first()
db.session.delete(delet_agendamento)
db.session.commit()
return jsonify({
'message': 'Agendamento '
}),200
except Exception as e:
print(e)
return bad_request(403,'erro ao deletar o agendamento')
def teste():
try:
dados = request.get_json()
with db.engine.connect() as conn:
query = text("""
select t1.id_sala,
t1.numero,
t1.quantidade,
t1.sala_tipo_id,
t3.descricao as salas_tipo
from salas t1
join sala_tipo t3 on
t1.sala_tipo_id = t3.sala_tipo_id
where not exists (select *
from agendamento t2
where t1.id_sala = t2.sala_id and
(t2.data = :data) and not (t2.horario_inicio between :horario_inicio and :horario_final) and not
(t2.horario_final between :horario_inicio and :horario_final) ) and t1.sala_tipo_id = :sala_tipo_id and not exists (
select t1.id_sala,t1.numero,t4.projetor,t4.luzes,t4.ar,t4.limpeza
from sala_status t4
where t1.id_sala = t4.sala_id and t4.ar = '1' or t4.projetor = '1' or t4.luzes = '1' or t4.ar = '1' or t4.limpeza= '1')
""")
result = conn.execute(
query,
data=dados['data'],
horario_inicio=dados['horario_inicio'],
horario_final=dados['horario_final'],
sala_tipo_id=dados['sala_tipo_id']).fetchall()
items = []
for row in list(result):
items.append({
'id_sala': row[0],
'numero': row[1],
'quantidade': row[2],
'sala_tipo_id': row[3],
'salas_tipo': row[4]
})
message = {'items': items}
# print(message)
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'não foi possivel realizar a consulta')
def new_tag():
data = request.get_json()
data['ativo'] = 'S'
try:
tag = Tag()
tag.from_dict(data)
db.session.add(tag)
db.session.commit()
message = {'message': 'Tag criada'}
return jsonify(message), 200
except Exception as identifier:
return bad_request(403, 'Tag já existe')
def delete_direcao():
try:
data = request.get_json()
print(data)
CoresDirecao.query.filter(CoresDirecao.id_cores_direcao ==
data['id_cores_direcao']).delete()
# print(dir_cor)
db.session.commit()
return jsonify({"msg": 'cor deletada com sucesso'}), 204
except Exception as e:
print(e)
return bad_request(503, f"""error ao fazer delete""")
def get_predict():
try:
data = request.get_json()
# print(request)
# print(request.data)
data_receveid = json.loads(request.data)
# print(data_receveid)
headers = {"content-type": "application/json"}
img = convert_image(data_receveid['image'])
response = requests.post(
"http://34.72.212.91:9000/v1/models/IA_PI-VII:predict",
data=img,
headers=headers) # request ao tensorflow serving
predictions = response.json()['predictions']
labels = {0: 'blue', 1: 'green', 2: 'red', 3: 'yellow'}
predict_class = np.argmax(predictions[0])
predict_cor = labels[predict_class]
cor = Cores.query.filter_by(nome=predict_cor).first()
print(cor)
direcao = CoresDirecao.query.filter_by(cor_id=cor.id_cores).first()
print(direcao)
mover_motor = Direcao.query.filter_by(
id_direcao=direcao.direcao_id).first()
print(mover_motor)
return jsonify({
'predict_class': predict_cor,
'direcao': str(mover_motor.id_direcao)
})
except Exception as e:
print(e)
return bad_request(500, 'não foi possivel fazer a previsão da cor.')
def set_agendamento():
try:
data = request.get_json()
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
data['usuario_id'] = user_id
agend = Agendamento()
agend.from_dict(data)
db.session.add(agend)
db.session.commit()
return jsonify({'message': 'Agendamento realizado com sucesso'}), 200
except Exception as e:
return bad_request(403, 'Erro ao inserir agendamento')
def salass_manutencao():
try:
data = date.today()
with db.engine.connect() as conn:
query = text("""
select distinct count(sala_id)
from sala_status
where ar = '1' or projetor = '1' or luzes = '1' or ar = '1'
""")
result = conn.execute(query, data_atual=data).fetchall()
message = {'salas': result[0][0]}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'não foi possivel realizar a consulta')
def sala_manutencao():
try:
dados = request.get_json()
sala_padrao = {'ar': 0, 'luzes': 0, 'projetor': 0}
status_sala = SalasStatus.query.filter_by(
sala_id=dados['id_sala']).first()
status_sala.from_dict(sala_padrao)
db.session.commit()
message = {'message': 'Atualização feita com sucesso'}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel realizar a atualização')
def enviar_email():
try:
data = request.get_json()
if data['cadastro'] ==1:
subject = 'Cadastro Efetuado com sucesso'
body = f"""Seu cadastro foi efetuado com sucesso
login:{data['email']}
senha:{data['senha']}
Pedimos por gentileza para trocar sua senha no seu primeiro acesso.
Ir na are de perfil para trocar sua senha
link: www.uol.com.br
"""
elif data['cadastro'] == 0:
subject = 'Feedback aula'
body = """
Segue link do Formulario para nos contar como estava a sala apos a aula
link: www.uol.com.br
"""
elif data['cadastro'] == 2:
subject = 'Alteração de senha'
body = f"""
Foi solicitado uma alteração de senha,
login:{data['email']}
senha:{data['senha_nova']}
Pedimos por gentileza para trocar sua senha no seu primeiro acesso.
Ir na are de perfil para trocar sua senha
"""
# d = m.Mail(data['email'],body,subject)
# d.enviar()
# queue.queue(d.email,d.msg)
msg = Message(subject,sender=current_app.config['MAIL_USERNAME'],recipients=[data['email']])
msg.body = body
queue.thread_flask(msg)
return jsonify({
'message':'adsasda'
}),200
except Exception as e:
print(e)
return bad_request(403,'nao foi possivel envia email')
def sala_alugada():
try:
data = date.today()
with db.engine.connect() as conn:
query = text("""
select DISTINCT COUNT(a.id_agendamento) from agendamento as a
join salas as s on
a.sala_id = s.id_sala
where a.data = :data_atual
""")
result = conn.execute(query, data_atual=data).fetchall()
message = {'salas': result[0][0]}
return jsonify(message), 200
except Exception as e:
print(e)
return bad_request(403, 'não foi possivel realizar a consulta')
def att_status():
try:
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
data = request.get_json()
print(data)
envio_ = Envio.query.filter(Envio.token == data['token']).first()
user_ = Usuario.query.filter(Usuario.id_usuario == user_id).first()
pedido_ = Pedido.query.filter(
Pedido.cod_pedido == envio_.codigo_pedido).first()
# new_pedido = Pedido()
# new_pedido.from_dict(pedido_.to_dict())
# print(pedido_.to_dict())
if user_.funcao_id:
if pedido_.status_id < 4:
pedido_.status_id += 1
else:
pedido_.status_id = 4
else:
pedido_.status_id = 4
db.session.commit()
message = {'msg': 'status do pedido atualizado com sucesso'}
return jsonify(message), 201
except Exception as e:
print(e)
return bad_request(403, 'Não foi possivel atualizar status ')
def get_salas():
try:
users = Salas.query.join(SalasTipo,Salas.sala_tipo_id == SalasTipo.sala_tipo_id)\
.add_columns(Salas.id_sala,Salas.numero,Salas.quantidade,SalasTipo.descricao)\
.all()
items = []
for row in users:
items.append({
'id_sala': row[1],
'numero': row[2],
'quantidade': row[3],
'salas_tipo': row[4]
})
message = {'items': items}
return jsonify(message), 200
except Exception as identifier:
return bad_request(403, 'Nao foi possivel trazer as salas')
def delet_user():
try:
token = request.headers.get('x-access-token')
verify_token = decode_token(token)
user_id = verify_token['id_user']
data = request.get_json()
user = Usuario.query.filter_by(id_usuario=user_id).first()
user.ativo = 'N'
db.session.commit()
message = {'message': 'usuario deletado'}
return jsonify(message), 200
except Exception as e:
return bad_request(403, 'erro ao deletar usuario')
def direcao_():
try:
#print(request.method)
if request.method == 'GET':
cor = CoresDirecao.query.join(Direcao,Direcao.id_direcao == CoresDirecao.direcao_id) \
.join(Cores,Cores.id_cores == CoresDirecao.cor_id) \
.add_columns(CoresDirecao.id_cores_direcao,Cores.nome,Direcao.nome) \
.all()
items = []
for item in cor:
items.append({
"id_cores_direcao": str(item[1]),
"cor": str(item[2]),
"direcao": str(item[3])
})
message = {"items": items}
return jsonify(message), 200
data = request.get_json()
print(data)
dir_cor = CoresDirecao()
dir_cor.from_dict(data)
if request.method == 'POST':
db.session.add(dir_cor)
db.session.commit()
return jsonify({"msg": 'cor inserida com sucesso'}), 201
except Exception as e:
print(e)
return bad_request(
503,
f"""error ao fazer a consulta no metodo {str(request.method)}""")
def edit_user():
try:
data = request.get_json()
user = Usuario.query.filter_by(id_usuario=data['id_usuario']).first()
tag = Tag.query.filter_by(id_tag=user.tag_id).first()
tag.ativo = 'S'
user.from_dict(data)
tag_ativa = Tag.query.filter_by(id_tag=data['tag_id']).first()
tag_ativa.ativo = 'N'
db.session.commit()
message = {'message': 'usuario alterado'}
return jsonify(message), 200
except Exception as identifier:
return bad_request(403, 'erro ao editar usuario')
