def create_new_room():
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
if decoded == False:
return invalid_session()
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
except jwt.exceptions.DecodeError:
return invalid_session()
params = get_room_info_from_request()
connection = db.get_connection()
try:
room_id = room_model.create_room(params, connection)
room_model.update_ip(room_id, params[1], connection)
connection.commit()
room_info = room_model.get_room(room_id, connection)
except IntegrityError as e:
connection.rollback()
return db_error(e)
finally:
connection.close()
return success(room_info)
def report_measurement(room_id):
# 토큰의 uid와 입력된 uid가 일치하는지 검사한다.
try:
access_token = request.headers['Authorization']
except KeyError:
return invalid_session()
connection = db.get_connection()
try:
room_info = room_model.get_room(room_id, connection)
if access_key.valid(access_token, room_info['ip'],
room_info['id']) == False:
return invalid_session()
data = request.json
datetime = data["datetime"]
temperature = data["temperature"]
humidity = data["humidity"]
measurement_model.insert((room_id, datetime, temperature, humidity),
connection)
connection.commit()
except IntegrityError as e:
connection.rollback()
return db_error(e)
except KeyError:
connection.rollback()
return invalid_param()
finally:
connection.close()
return success('OK')
def start_stream(board_id):
con = db.get_connection()
stream_table = con['stream']
last_event_id = request.headers.get('Last-Event-Id', 0)
sse.publish(list(stream_table.find(last_event_id=last_event_id)),
channel=board_id)
return io_util.set_response_json(data='message send!!')
def create_session():
connection = db.get_connection()
data = request.json
email = data["email"]
passwd = data["password"]
# 사용자 패스워드 조회
try:
result = user_model.get_password(email, connection)
if (result):
if password.valid(result[1], passwd):
token = session_token.encode(result[0])
session_model.insert(token, connection)
connection.commit()
return success({'uid': result[0], 'token': token})
else:
return invalid_password()
except IntegrityError as e:
connection.rollback()
return db_error.response(e)
finally:
connection.close()
return no_user()
def update_session():
# 토큰의 uid와 입력된 uid가 일지하는지 검사한다.
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
data = request.json
uid = data['uid']
if (decoded['uid'] != uid):
return invalid_param('Invalid User')
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
except jwt.exceptions.DecodeError:
return invalid_session()
# 새로운 토근을 발급한다
connection = db.get_connection()
try:
new_token = session_token.encode(uid)
session_model.update(auth_token, new_token, connection)
connection.commit()
except IntegrityError as e:
connection.rollback()
return db_error.response(e)
finally:
connection.close()
return success({'uid': uid, 'token': new_token})
def delete_session():
# 토큰의 uid와 입력된 uid가 일지하는지 검사한다.
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
uid = request.args.get('uid')
if (decoded['uid'] != uid):
return invalid_param('Invalid User')
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
# 세션 레코드를 삭제한다.
connection = db.get_connection()
try:
result = session_model.delete(auth_token, connection)
connection.commit()
except IntegrityError as e:
connection.rollback()
return db_error.response(e)
finally:
connection.close()
return success('OK')
def getMusculos(documento):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
musculos = dbejercicios.info_musculo
retorno = dumps(musculos.find({"paciente.documento": documento}))
return jsonify(retorno)
finally:
con.close()
print('coneccion cerrada')
def getPacientes():
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
retorno = dumps(pacientes.find({}))
return jsonify(retorno)
finally:
con.close()
print('coneccion cerrada')
def getequipos():
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
retorno = dumps(equipos.find({}))
return jsonify(retorno)
finally:
con.close()
print('coneccion cerrada')
def getMusculosLista():
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
musculos = dbejercicios.musculos
retorno = list(musculos.find({}))
lista = [d['musculo'] for d in retorno]
return jsonify({'data': lista, 'status': 200})
finally:
con.close()
print('coneccion cerrada')
def getListequipo(parametro='documento'):
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
retorno = list(equipos.find({}))
lista = [d[parametro] for d in retorno]
return jsonify({'data': lista, 'status': 200})
finally:
con.close()
print('coneccion cerrada')
def getListPaciente(parametro='documento'):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
retorno = list(pacientes.find({}))
lista = [d[parametro] for d in retorno]
return jsonify({'data': lista, 'status': 200})
finally:
con.close()
print('coneccion cerrada')
class Book:
conn = get_connection()
def __init__(self, _id=None):
self._id = None
self._author = None
self._title = None
self._changed = False
if _id is not None:
self._load(_id)
@property
def id(self):
return self._id
@property
def author(self):
return self._author
@property
def title(self):
return self._title
@author.setter
def author(self, value):
self._author = value
self._changed = True
@title.setter
def title(self, value):
self._title = value
self._changed = True
def _load(self, _id):
cursor = self.conn.cursor()
cursor.execute(SELECT_STATEMENT, (_id, ))
book = cursor.fetchone()
self._id, self._title, self._author = book
def save(self):
if not self._changed:
return
cursor = self.conn.cursor()
if not self.id:
cursor.execute(INSERT_STATEMENT, (self.author, self.title))
self._id = cursor.lastrowid
else:
cursor.execute(UPDATE_STATEMENT,
(self.author, self.title, self.id))
self.conn.commit()
self._changed = False
def guardarMusculo(data):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
musculos = dbejercicios.musculos
musculos.insert(data)
return jsonify({'message': 'musculo insertado', 'status': 200})
except:
return jsonify({'message': 'fallo en la insercion', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def createPatient(data):
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
equipos.insert(data)
return jsonify({'message': 'equipo insertado', 'status': 200})
except:
return jsonify({'message': 'fallo en la insercion', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def createPatient(data):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
pacientes.insert(data)
return jsonify({'message': 'paciente insertado', 'status': 200})
except:
return jsonify({'message': 'fallo en la insercion', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def deletePatientDocument(documento):
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
equipos.delete_many({'documento': documento})
return jsonify({'message': 'equipo eliminado', 'status': 200})
except:
return jsonify({'message': 'fallo al eliminar equipo', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def deletePatientDocument(documento):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
pacientes.delete_many({'documento': documento})
return jsonify({'message': 'paciente eliminado', 'status': 200})
except:
return jsonify({
'message': 'fallo al eliminar paciente',
'status': 500
})
finally:
con.close()
print('coneccion cerrada')
def editarequipo(data):
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
print(data['data'])
equipos.find_one_and_update({'documento': data['documento']},
{'$set': data['data']})
return jsonify({'message': 'equipo editado', 'status': 200})
except:
return jsonify({'message': 'fallo al editar un equipo', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def guardarMusculoInfo(data):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
musculosInfo = dbejercicios.info_musculo
musculos = dbejercicios.musculos
pacientes = dbejercicios.pacientes
try:
pacienteGuardar = list(
pacientes.find({'documento': data['documento']}))
musculoGuardar = list(musculos.find({'musculo': data['musculo']}))
if (len(pacienteGuardar) == 1 and len(musculoGuardar) == 1):
informacionGuardar = data['data']
informacionGuardar['paciente'] = {
'documento': pacienteGuardar[0]['documento'],
'id_documento': str(pacienteGuardar[0]['_id'])
}
informacionGuardar['musculo'] = {
'nombre': musculoGuardar[0]['musculo'],
'id_nombre_musculo': str(musculoGuardar[0]['_id'])
}
print(informacionGuardar)
musculosInfo.insert(informacionGuardar)
return jsonify({
'message': 'informacion muscular guardada',
'status': 200
})
elif (len(pacienteGuardar) != 1):
return jsonify({
'message': 'paciente no existe',
'status': 500
})
else:
return jsonify({'message': 'musculo no existe', 'status': 500})
except:
return jsonify({'message': 'fallo en la insercion', 'status': 500})
except:
return jsonify({'message': 'fallo en la insercion', 'status': 500})
finally:
con.close()
print('coneccion cerrada')
def getMusculos(documento):
con = db.get_connection()
dbevaluaciones = con.Modeloevaluaciones
try:
equipos = dbevaluaciones.equipos
datos_ejercio = dbevaluaciones.datos_evaluacion
evaluaciones = dbevaluaciones.evaluaciones
musculos = dbevaluaciones.musculos
equipo = dict(equipos.find_one({'documento': documento}))
capturasequipo = list(
datos_ejercio.find({'equipo': str(equipo['_id'])}))
respuesta = []
if (len(capturasequipo) > 0):
for registro in capturasequipo:
evaluacionRealizado = evaluaciones.find_one(
{'_id': ObjectId(registro['evaluacion'])})
musculoRealizado = musculos.find_one(
{'_id': ObjectId(registro['musculo'])})
del registro['evaluacion'], registro['musculo'], registro[
'equipo'], registro['_id']
del evaluacionRealizado['_id'], musculoRealizado['_id']
evaluacionDatos = {
**registro,
**evaluacionRealizado,
**musculoRealizado
}
respuesta.append(evaluacionDatos)
return {
'message': 'evaluaciones del equipo',
'status': 200,
'data': respuesta
}
else:
return jsonify({
'message': 'equipo no tiene registros en la base de datos',
'status': 404
})
finally:
con.close()
print('coneccion cerrada')
def getMusculos(documento):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
datos_ejercio = dbejercicios.datos_ejercicio
ejercicios = dbejercicios.ejercicios
musculos = dbejercicios.musculos
paciente = dict(pacientes.find_one({'documento': documento}))
capturasPaciente = list(
datos_ejercio.find({'paciente': str(paciente['_id'])}))
respuesta = []
if (len(capturasPaciente) > 0):
for registro in capturasPaciente:
ejercicioRealizado = ejercicios.find_one(
{'_id': ObjectId(registro['ejercicio'])})
musculoRealizado = musculos.find_one(
{'_id': ObjectId(registro['musculo'])})
del registro['ejercicio'], registro['musculo'], registro[
'paciente'], registro['_id']
del ejercicioRealizado['_id'], musculoRealizado['_id']
ejercicioDatos = {
**registro,
**ejercicioRealizado,
**musculoRealizado
}
respuesta.append(ejercicioDatos)
return {
'message': 'ejercicios del paciente',
'status': 200,
'data': respuesta
}
else:
return jsonify({
'message': 'paciente no tiene registros en la base de datos',
'status': 404
})
finally:
con.close()
print('coneccion cerrada')
def create_new_user():
data = request.json
email = data["email"]
pwd = data["password"]
confirm = data["confirm"]
if (pwd != confirm):
return invalid_password()
connection = db.get_connection()
try:
user_model.insert(email, pwd, connection)
connection.commit()
except IntegrityError as e:
return db_error(e)
finally:
connection.close()
return success('OK')
def editarPaciente(data):
con = db.get_connection()
dbejercicios = con.ModeloEjercicios
try:
pacientes = dbejercicios.pacientes
print(data['data'])
pacientes.find_one_and_update({'documento': data['documento']},
{'$set': data['data']})
return jsonify({'message': 'paciente editado', 'status': 200})
except:
return jsonify({
'message': 'fallo al editar un paciente',
'status': 500
})
finally:
con.close()
print('coneccion cerrada')
def update_humidifier(room_id):
# 토큰의 uid와 입력된 uid가 일지하는지 검사한다.
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
if decoded == False:
return invalid_session()
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
except jwt.exceptions.DecodeError:
return invalid_session()
connection = db.get_connection()
try:
ip = room_model.get_room_ip(room_id, connection)
url = SENSOR_URL.format(ip, 'humidifier')
headers = {'content-type': 'application/json'}
data = request.json
payload = {
"status": data["status"]
}
response = requests.request("PUT", url, data=json.dumps(payload), headers=headers)
if (response.status_code == 200 and data["status"] == 'ON'):
print ('ON')
else:
print ('OFF')
except IntegrityError as e:
return db_error(e)
finally:
connection.close()
if (response.status_code == 200):
return success('OK')
elif (response.status_code == 400):
return invalid_param()
def get_users():
# 토큰의 uid와 입력된 uid가 일지하는지 검사한다.
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
if decoded == False:
return invalid_session()
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
except jwt.exceptions.DecodeError:
return invalid_session()
connection = db.get_connection()
try:
user_list = user_model.get_users(connection)
except IntegrityError as e:
return db_error(e)
finally:
connection.close()
return success(user_list)
def get_measurements(room_id):
# 토큰의 uid와 입력된 uid가 일지하는지 검사한다.
try:
auth_token = request.headers['Authorization']
decoded = session_token.decode(auth_token)
if decoded == False:
return invalid_session()
elif decoded['exp'] < int(time.time()):
return session_exp()
except KeyError:
return invalid_session()
except jwt.exceptions.DecodeError:
return invalid_session()
data = request.json
try:
start = request.args.get('start')
except KeyError:
start = int(time.time()) - (60 * 60 * 24)
try:
end = request.args.get('end')
except KeyError:
end = start + (60 * 60 * 24)
connection = db.get_connection()
try:
user_list = measurement_model.get_measurements(room_id, start, end,
connection)
except IntegrityError as e:
return db_error(e)
finally:
connection.close()
return success(user_list)
def list():
print(db.get_connection())
return {'message': 'Este es el servicio que lista de equipos'}, 200
def list():
print(db.get_connection())
return "EServicio para listar los equipos"
def list():
print(db.get_connection())
return "Este es el servicio que lista de pacientes"
