def register(self):
# Comprobar expiración del token
tokens.server_token().exp_token()
# Mensaje post a enviar
payload = "{\"message\":\"" + self.config[
'MESSAGE'] + "\",\"menu\":" + self.config[
'MENU'] + ",\"client_id\":\"" + self.config[
'CLIENT_ID'] + "\",\"address\":\"" + self.config[
'ADDRR'] + "\",\"canUse\":[" + self.config[
'CANUSE'] + "]}"
# Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token['Data']['id_token'],
'Content-length': str(len(payload))
}
# Conexión con el dispatcher
data = client.peticion("POST", self.config['HOSTNAME'],
self.config['PORT'],
self.config['NEW_FUNCTIONALITY'], payload,
headers, self.config['RUTA_CERT'])
print(data)
def deregister(self):
# It checks expiration time of the token
tokens.server_token().exp_token()
# It obtains the token
token = tokens.server_token().get_tokenDB()
# It deletes the funcionality in the database
data = requests.delete(
self.config['DELETE_FUNCTIONALITY'] + "?client_id=" +
self.config['CLIENT_ID'],
headers={'Authorization': 'Bearer ' + token['Data']['id_token']},
verify=self.config['RUTA_CERT'])
print(data.content)
def get_user_data(self, user_number):
# It checks expiration time of the token
tokens.server_token().exp_token()
# It obtains the token
token = tokens.server_token().get_tokenDB()
# Connection with the API gateway
data_DB = requests.post(self.config['DB_REQUEST'], json={"url": "users/_find?criteria={\"id_signal\":\""+
user_number+"\"}", "data": None}, headers={'Authorization': 'Bearer ' + token['Data']['id_token']}, verify=
self.config['RUTA_CERT'])
# It obtains the patient data
return data_DB.json()['results'][0]
def update_image(location, data): #localización base de datos
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Mensaje a enviar
data['basedOn'] = [{"identifier" : {"use": "temp",
"value": "Procedure_Monitorizacion_Psoriasis",
"assigner": "UNIZAR"
}}]
data['device'] = {"identifier": { "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}}
payload = json.dumps(data)
#Petición put a la base de datos para actualizar el recurso
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('PUT', config['URL_FHIR']+location, payload, headers)
r = conn.getresponse()
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation Update image')
data = json.loads(data)
print(data)
conn.close()
def get_image(location, user): #localización base de datos, nombre de usuario como identificador
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Petición get a la base de datos
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('GET', config['URL_FHIR']+location, headers=headers)
r = conn.getresponse()
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation GET image')
data = json.loads(data)
#print(data)
conn.close()
#La imagen está codificada en base64
imagen = base64.b64decode(data['content']['data'])
#La imagen se almacena para su tratamiento
file = open('imagenes/' + user + '/reciv.jpg','wb')
#file = open('imagenes/'+user+'.jpg','wb')#para pruebas
file.write(imagen)
file.close()
return data
def change_user_data(self, user_number, data_user):
# It checks expiration time of the token
tokens.server_token().exp_token()
# POST message to send
data_user = json.dumps(data_user)
data_user = data_user.replace('"','\"')
# It obtains the token
token = tokens.server_token().get_tokenDB()
# Connection with the API gateway
resp = requests.post(self.config['DB_REQUEST'], json={"url": "users/_update", "data": "criteria={\"id_signal\": "
"\""+user_number+"\"}&newobj="+data_user},
headers={'Authorization': 'Bearer ' + token['Data']['id_token']}, verify=
self.config['RUTA_CERT'])
print(resp)
def do_get(url):
token_p = tokens.server_token().get_tokenDB()
r = requests.get(
url,
headers={'Authorization': 'Bearer ' + token_p['Data']['id_token']},
verify=config['RUTA_CERT'])
if debug <= 0:
print(r.status_code, 'Get Mensaje recibido')
return r
def register(self):
# It checks expiration time of the token
tokens.server_token().exp_token()
# It obtains the token
token = tokens.server_token().get_tokenDB()
# It adds the functionality in the database
data = requests.post(
self.config['NEW_FUNCTIONALITY'],
json={
"client_id": self.config['CLIENT_ID'],
"message": self.config['MESSAGE'],
"menu": self.config['MENU'],
"address": self.config['ADDRR'],
"canUse": [self.config['CANUSE']]
},
headers={'Authorization': 'Bearer ' + token['Data']['id_token']},
verify=self.config['RUTA_CERT'])
print('Registration: ', data.content)
def deregister(self):
# Comprobar expiración del token
tokens.server_token().exp_token()
# Mensaje post a enviar
payload = "{\"client_id\":\"" + self.config['CLIENT_ID'] + "\"}"
# Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token['Data']['id_token'],
'Content-length': str(len(payload))
}
# Conexión con el dispatcher
data = client.peticion("DELETE", self.config['HOSTNAME'],
self.config['PORT'],
self.config['DELETE_FUNCTIONALITY'], payload,
headers, self.config['RUTA_CERT'])
print(data)
def do_post_reenviar(url, body):
token_p = tokens.server_token().get_tokenDB()
payload = bytes(json.dumps(body), 'utf-8')
header = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token_p['Data']['id_token'],
'Content-length': str(len(payload))
}
r = requests.post(url,
json.dumps(body),
headers=header,
verify=config['RUTA_CERT'])
if debug <= 0:
print(r.status_code, 'Mensaje enviado')
if not str(r.status_code).startswith('2'):
print(r.content)
print('URL', r.url)
return r
def do_post(url, body, attachment, data):
token_p = tokens.server_token().get_tokenDB()
# It avoids errors with the URL (% and +)
body = urllib.parse.quote(body.encode('UTF-8'))
AppResp = message.AppResp
if not body:
AppResp['message']['body'] = None
else:
AppResp['message']['body'] = body
if not attachment:
AppResp['message']['attachments'] = None
else:
AppResp['message']['attachments'] = attachment
AppResp['user'] = data['user']
AppResp['platform'] = data['platform']
AppResp['message']['timestamp'] = int(time.time())
payload = bytes(json.dumps(AppResp), 'utf-8')
header = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token_p['Data']['id_token'],
'Content-length': str(len(payload))
}
try:
r = requests.post(url,
json.dumps(AppResp),
headers=header,
verify=config['RUTA_CERT'])
except:
print('ERROR AL ENVIAR MENSAJE')
return '400'
else:
if debug <= 0:
print(r.status_code, 'Mensaje enviado')
if not str(r.status_code).startswith('2'):
print(r.content)
print('URL', r.url)
return r
def device_update_DB(estado): #active, inactive
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Mensajes a enviar
##Device
payload = {"resourceType": "Device",
#"id": "776", #sujeto a cambios en el DB
"identifier": [{ "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}],
"status": estado,# active | inactive | entered-in-error | unknown
"type" : { "coding": [{"system": "http://snomed.info/sct",
"code": "701654001",
"display": "Self-care monitoring web-based application software"
}],
"text": "Aplicación móvil de monitoirzación"
},
"version": "1.0",
"contact": [{ "system": "email",
"value": "*****@*****.**"
}],
"url": "https://procesado.ehealthz.es",
"note": [{"authorString" : "Daniel Vicente Moya",
"time" : "2018-04-25T13:52:07+02:00",
"text": "Device en estado de desarrollo y pruebas"
}]
}
payload = json.dumps(payload)
##DeviceMetric
if estado == "active":
status = "on"
elif estado == "inactive":
status = "off"
else:
status = "entered-in-error"
payload2 = {"resourceType" : "DeviceMetric",
#"id": "777", #sujeto a cambios en el DB
"identifier" : {"use": "temp",
"value": "Procesado_imagen_Metric",
"assigner": "UNIZAR"
},
"type" : {"coding":[{"system": "urn:iso:std:iso:11073:10101",
"code": "_BSA",
"display": "Body Surface Area"
}],
"text": "Área superficie del cuerpo"
},
"unit" : {"coding":[{"system": "http://unitsofmeasure.org",
"code": "cm2",
"display": "square centimeter"
}],
"text": "centímetros cuadrados"
},
"source" : {"identifier": { "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}},
#"parent" : {"reference": "Procesado_imagen_Component"},
"operationalStatus" : status, # on | off | standby | entered-in-error
"color" : "red",
"category" : "measurement"
}
payload2 = json.dumps(payload2)
#Petición put a la base de datos para actualizar recursos
##Device
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('PUT', config['URL_FHIR']+"Device?identifier:value=Procesado_imagen", payload, headers)#La id del Device puede estar sujeta a cambios (se recomienda comporbaren el DB)
r = conn.getresponse()
header = r.getheaders()
data = r.read()
print(r.status, r.reason, 'DB_FHIR Update Device')
data = json.loads(data)
print(data)
##DeviceMetric
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('PUT', config['URL_FHIR']+"DeviceMetric?identifier:value=Procesado_imagen_Metric", payload2, headers) #La id del DeviceMetric puede estar sujeta a cambios (se recomienda comporbaren el DB)
r = conn.getresponse()
header = r.getheaders()
data = r.read()
print(r.status, r.reason, 'DB_FHIR Update DeviceMetric')
data = json.loads(data)
print(data)
conn.close()
def post_data(data, user, patient_id):
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Mensaje a enviar
file = open('imagenes/' + user + '/contour.jpg','rb')
image = file.read()
size_image = len(image)
image = base64.b64encode(image) #paso archivo imagen a base 64
image = str(image, 'utf-8')
file.close()
file = open('imagenes/' + user + '/datosDB.dat','rb')
data_file = file.read()
size_data_file = len(data_file)
data_file = base64.b64encode(data_file) #paso archivo imagen a base 64
data_file = str(data_file, 'utf-8')
file.close()
payload = {"resourceType": "Observation",
"basedOn": [{"identifier" : {"use": "temp",
"value": "Monitorizacion_Psoriasis",
"assigner": "UNIZAR"
}},
{"identifier" : {"use": "temp",
"value": "Procedure_Monitorizacion_Psoriasis",
"assigner": "UNIZAR"
}}
],
"status": "registered", #"preliminary"
"code": {"coding": [{"system": "http://loinc.org",
"code": "10206-1",
"display": "Physical findings of Skin Narrative"
},
{"system": "http://unitsofmeasure.org",
"code": "cm2",
"display": "square centimeter"
}],
"text": "Hallazgos fisicos sobre la piel"
},
"subject": {"reference": "Patient/"+patient_id},
"valueString": data,
"device": {"identifier": { "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}},
"component": [{"code": {"coding": [{"system": "http://loinc.org",
"code": "10206-1",
"display": "Physical findings of Skin Narrative"
},
{"system": "http://hl7.org/fhir/digital-media-type",
"code": "photo",
"display": "Photo"
}],
"text": "Hallazgos fisicos sobre la piel"
},
"valueAttachment": {"contentType": "image/jpeg",
"data": image,
"size": size_image,
"creation": time.strftime("%Y-%m-%d"+"T"+"%I:%M:%S"+"+02:00")
},
},
{"code": {"coding": [{"system": "http://loinc.org",
"code": "10206-1",
"display": "Physical findings of Skin Narrative"
},
{"system": "http://unitsofmeasure.org",
"code": "cm2",
"display": "square centimeter"
}],
"text": "Hallazgos fisicos sobre la piel"
},
"valueAttachment": {"contentType": "application/octet-stream'",
"data": data_file,
"size": size_data_file,
"creation": time.strftime("%Y-%m-%d"+"T"+"%I:%M:%S"+"+02:00")
}
}]
}
payload = json.dumps(payload)
#Petición post a la base de datos
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('POST', config['URL_FHIR']+"Observation", payload, headers)
r = conn.getresponse()
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation Save Data')
data = json.loads(data)
print(data)
conn.close()
def enviar(data, attach, body):
if attach != None:
#Codificado de la imagen en base 64
file = open(attach, 'rb')
data_file = file.read()
length_image = int(len(data_file))
data_file = base64.b64encode(data_file)
data_file = str(data_file, 'utf-8')
file.close()
attachment = {}
attachment['contentType'] = "image/jpeg"
attachment['data'] = data_file
attachment['size'] = length_image
# Mensaje a enviar
payload = {}
payload['message'] = {}
payload['user'] = data['user']
payload['platform'] = data['platform']
payload['message']['timestamp'] = int(time.time())
payload['message']['body'] = body
payload['message']['attachments'] = attachment
payload = json.dumps(payload)
payload = bytes(payload, 'utf-8')
# Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token['Data']['id_token'],
'Content-length': str(len(payload))
}
resp = client.peticion('POST', config['HOSTNAME'], config['PORT'],
config['URL_ATTACHMENT'], payload, headers,
config['RUTA_CERT'])
print(resp)
else:
attachment = None
# Mensaje a enviar
payload = {}
payload['message'] = {}
payload['user'] = data['user']
payload['platform'] = data['platform']
payload['message']['timestamp'] = int(time.time())
payload['message']['body'] = body
payload['message']['attachments'] = attachment
payload = json.dumps(payload)
payload = bytes(payload, 'utf-8')
# Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token['Data']['id_token'],
'Content-length': str(len(payload))
}
resp = client.peticion('POST', config['HOSTNAME'], config['PORT'],
config['URL_MESSAGE'], payload, headers,
config['RUTA_CERT'])
print(resp)
def DB_procedure_request_creation():
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Se comprueba si esta creado
#Petición get a la base de datos
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('GET', config['URL_FHIR']+"ProcedureRequest?identifier:value=Procedure_Monitorizacion_Psoriasis", headers=headers)
r = conn.getresponse()
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation GET ProcedureRequest')
data = json.loads(data)
print(data)
conn.close()
if int(data['total']) != 0:
pass #Si ya está creado no lo vuelve a crear.
else:
#Mensaje a enviar
payload = {"resourceType": "ProcedureRequest",
#"id": "800",
"identifier" : [{"use": "temp",
"value": "Procedure_Monitorizacion_Psoriasis",
"assigner": "UNIZAR"
}],
"replaces" : [{"identifier" : {"use": "temp",
"value": "Monitorización_Psoriasis",
"assigner": "UNIZAR"
}}],
"status" : "active",
"intent" : "proposal",
#"priority" : "routine",
"code": {"coding": [{"system": "http://snomed.info/sct",
"code": "701654001",
"display": "Self-care monitoring web-based application software"
}],
},
"subject" : {"identifier": { "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}},
"authoredOn" : time.strftime("%Y-%m-%d"+"T"+"%I:%M:%S"+"+02:00"),
"reasonCode" : [{"coding": [{"system": "http://snomed.info/sct",
"code": "9014002",
"display": "psoriasis"
}]
}]
}
payload = json.dumps(payload)
#Petición post a la base de datos para crear recurso
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('POST', config['URL_FHIR']+"ProcedureRequest", payload, headers)
r = conn.getresponse()
header = r.getheaders()
data = r.read()
print(r.status, r.reason, 'DB_FHIR Create ProcedureRequest')
data = json.loads(data)
print(data)
conn.close()
def run(server_class=http.server.HTTPServer,
handler_class=HTTPServer_RequestHandler):
print('Starting server...')
# Server Configuration from file config.cfg
config = {}
cfg = configparser.ConfigParser()
if not cfg.read(["config.cfg"]):
print("File does not exist")
if cfg.has_option("net", "ip"): #ip
config['ip'] = cfg.get("net", "ip")
else:
print("Config file need to have ip field")
#if cfg.has_option("net", "name"): #host_name
# config['host_name'] = cfg.get("net", "name")
#else:
# print ("Config file need to have name field")
if cfg.has_option("net", "port"): #port
config['port'] = int(cfg.get("net", "port"))
else:
print("Config file need to have port field")
if cfg.has_option("net", "file_key"): #file_key
config['file_key'] = cfg.get("net", "file_key")
else:
print("Config file need to have file_key field")
if cfg.has_option("net", "file_cert"): #file_key
config['file_cert'] = cfg.get("net", "file_cert")
else:
print("Config file need to have file_cert field")
#if cfg.has_option("net", "max_conect"): #max_conect
# max_conexiones = int(cfg.get("net", "max_conect"))
#else:
# print ("Config file need to have max_conect field")
# Create the kernel and learn AIML files for bot response
bot.initialize()
# Server settings
server_address = (config['ip'], config['port'])
httpd = server_class(server_address, handler_class)
#httpd.socket.listen(max_conexiones) #Límite de clientes conectados
# Seguridad https
httpd.socket = ssl.wrap_socket(
httpd.socket,
keyfile=config['file_key'], #keyfile = RUTA_KEY,
certfile=config['file_cert'], #certfile = RUTA_CERT,
server_side=True,
)
# Authentication token
tokens.server_token().get_token()
# Registro en el dispatcher
reg = registration.registration()
reg.register()
# Creación de recursos en la base FHIR si no existen
fhir_client.DB_device_creation()
fhir_client.DB_device_request_creation()
fhir_client.DB_procedure_request_creation()
# Cambio estado Device
fhir_client.device_update_DB("active")
# Run and Stop server
#while True:
try:
#Ejecución del servidor
httpd.serve_forever()
#httpd.handle_request() #handle one request (while loop needed)
print('Running server...')
print('Server port:', port)
except KeyboardInterrupt:
print('Keyboard interrupt received: EXITING')
finally:
#Desregistro en el dispatcher
dereg = deregistration.deregistration()
dereg.deregister()
#Cambio estado Device
fhir_client.device_update_DB("inactive")
#Apagado del servidor
httpd.shutdown()
httpd.server_close()
print('Server stopped')
return
def do_POST(self):
# Escuchar mensajes que llegan a /message
if self.path == "/message":
#Conprobación del token
decodedtoken = auth.auth_jwt(self.headers['Authorization'])
if decodedtoken == None:
self.send_error(401, 'Unauthorized')
return
#Extrae headers
#print(self.headers)
#Comprobación del tamaño del mensaje (evita bloqueos al recivir imágenes no deseadas)
if int(self.headers['Content-Length']) > 500:
self.send_error(431, 'Request Header Fields Too Large')
return
#Extracción del mensaje
try:
content_length = int(
self.headers['Content-Length']) # Get data size
post_data = self.rfile.read(int(content_length)) # Get data
#print(post_data)
except:
self.send_error(411, 'Length Required')
return
# Operaciones si el mensaje contiene un json
if self.headers['Content-Type'] == self.mimetypes["json"]:
#Descompresión del json
data = json.loads(post_data)
#print(data)
#Respuesta del bot
aux = data['message']['body']
aux = aux.split('/')
[responsebot, microservice, tarea] = bot.response(aux[0])
#Datos usuario para cambiar funcionalidad conectada
user = datos_user.userDB()
user_data = user.get_user_data(data['user'])
#print(user_data)
# Operación de eliminar vello
if tarea == 'Pelo':
an.quitar_pelo('imagenes/' + data['user'] + '/recort.jpg',
'imagenes/' + data['user'] + '/limpia.jpg')
#Se guarda que se hizo este proceso
dat_p.guardar_datos(data['user'], None, 'Pelo', None)
elif tarea == 'No_Pelo':
#Se guarda que se hizo este proceso
dat_p.guardar_datos(data['user'], None, 'No_Pelo', None)
#Análisis según tipo
elif tarea == 'Gota' or tarea == 'Placa':
#Se cargan los datos de las operaciones realizadas
[area_t, pelo,
area_marcador] = dat_p.cargar_datos(data['user'])
if pelo == 'Pelo': #Si se realizó la operación de eliminar vello
[area_t, area, puntos, v_pixels] = an.analisis(
tarea, 'imagenes/' + data['user'] + '/limpia.jpg',
'imagenes/' + data['user'] + '/recort.jpg',
'imagenes/' + data['user'] + '/keypoint.jpg',
'imagenes/' + data['user'] + '/contour.jpg')
elif pelo == 'No_Pelo': #Si no se realizó la operación de eliminar vello
[area_t, area, puntos, v_pixels] = an.analisis(
tarea, 'imagenes/' + data['user'] + '/recort.jpg',
'imagenes/' + data['user'] + '/recort.jpg',
'imagenes/' + data['user'] + '/keypoint.jpg',
'imagenes/' + data['user'] + '/contour.jpg')
#Se guardan los datos obtenidos
dat_p.guardar_datosDB(data['user'], area, puntos, v_pixels)
dat_p.guardar_datos(data['user'], str(area_t), None, None)
#Se cargan los datos de las operaciones realizadas
[area_t, pelo,
area_marcador] = dat_p.cargar_datos(data['user'])
#Se calcula el area se psoriasis
#area_marcador=17000 #Para pruebas
area_detec = an.calc_area(area_t, area_marcador, tarea)
#Envio de imagenes al cliente
#client_m.enviar(data,'imagenes/'+data['user']+'/keypoint.jpg',None)
client_m.enviar(
data,
'imagenes/' + data['user'] + '/contour.jpg',
#'El área total detectada es:'+str(area_t))
'El área total detectada es:' + str(area_detec) +
'cm2')
#Almacenado de datos
elif tarea == 'Guardar':
#Se cargan los datos de las operaciones realizadas
[area_t, pelo,
area_marcador] = dat_p.cargar_datos(data['user'])
#Se calcula el area se psoriasis
#area_marcador=17000 #Para pruebas
area_detec = an.calc_area(area_t, area_marcador, tarea)
#Envío de datos a la base de datos
fhir_client.post_data(area_detec, data['user'],
user_data['id'])
# Operaciones entrada microservicio
if microservice == 'Procesado_imagen':
#Envío de cambios en el perfil de usuario
user_data['runningFunctionality'] = 'Procesado_imagen'
user.change_user_data(data['user'], user_data)
#Creación de directorio para manejo de las imágenes de procesado del usuario
try:
os.mkdir('imagenes/' + data['user'])
except FileExistsError: #Si ya existe no lo crea de nuevo y salta el mensaje de error
pass
#Obtención de la imagen a analizar
dt_im = fhir_client.get_image(data['message']['body'],
data['user'])
fhir_client.update_image(data['message']['body'], dt_im)
#Recorte área marcadores
try:
area_marcador = an.recorte(
'imagenes/' + data['user'] + '/reciv.jpg',
'imagenes/' + data['user'] + '/recort.jpg')
dat_p.guardar_datos(data['user'], None, None,
str(area_marcador))
#print(area_marcador)
client_m.enviar(
data, 'imagenes/' + data['user'] + '/recort.jpg',
'Si el recorte no salió bien, puede salir y repetir.'
)
except:
client_m.enviar(
data, None,
'No se detectaron bien los marcadores. Salir y repetir la foto.'
)
pass
# Operación de salida del microservicio
elif microservice == 'Salir':
#Envío de cambios en el perfil de usuario
user_data['runningFunctionality'] = None
user.change_user_data(data['user'], user_data)
#Eliminación del directorio de imágenes del usuario
shutil.rmtree('imagenes/' + data['user'])
# Mensaje a enviar
payload = {}
payload['message'] = {}
payload['user'] = data['user']
payload['platform'] = data['platform']
payload['message']['timestamp'] = int(time.time())
#payload['message']['body'] = "Hola"
payload['message']['body'] = responsebot
payload['message']['attachments'] = None
payload = json.dumps(payload)
payload = bytes(payload, 'utf-8')
# Send response status code
self.send_response(200) #OK
# Send headers
token = tokens.server_token().get_tokenDB()
self.send_header('Authorization',
'Bearer ' + token['Data']['id_token'])
self.send_header('Content-Type', self.mimetypes["json"])
self.send_header('Content-Length', str(len(payload)))
self.send_header('Last-Modified',
self.date_time_string(time.time()))
self.end_headers()
# Send response
self.wfile.write(payload)
else:
self.send_error(415, 'Unsupported Media Type')
return
else:
# Send response status code
self.send_response(204) #No content
return
def handle_message(*args, **kwargs):
# It checks the token
tokenHeader = request.headers.get('Authorization')
decodedtoken = auth.auth_jwt(tokenHeader)
AppResp = {"user": "******",
"platform": "",
"message":
{"timestamp": 0,
"attachments": None,
"body": "Default"}
}
if not decodedtoken:
# Security Error; unauthorized
abort(401)
resp = '401'
print('Unauthorized')
else:
if request.headers['Content-Type'] == 'application/json':
# It obtains the json
data={}
data = json.loads(request.data.decode('utf-8'))
# It obtains the user information in the database, passing the id (phone number)
user = datos_user.userDB()
user_data = user.get_user_data(data['user'])
# It adds 'user' in the response
AppResp['user'] = data['user']
# Message sent by the user
aux = data['message']['body']
# It prevents the content of the input message from being wrong; only special characters
aux = normalize('NFC', aux)
aux = aux.replace('.', ' ').replace('?', ' ').replace('!', ' ')
m = re.match('^[^a-zA-Z0-9ñ]*$', aux)
if m:
mensaje = 'Vaya, no te he entendido. RepÃtemelo por favor'
AppResp['message']['body'] = mensaje
resp = app.make_response(json.dumps(AppResp))
user_data['runningFunctionality'] = config['client_id']
user.change_user_data(data['user'], user_data)
return resp
if debug <= -1:
print('NUEVA CONEXIÓN: ENTRADA', aux)
# A log is generated with the user and the input message
logger.info('- Origen: ' + data['user'] + ' Destino: Chatbot Message: ' + str(aux))
# Bot response
try:
# It sends the input message to the AIML
respuesta = str(kernel.respond(str(aux), data['user'])).replace('\\n', '\n').replace('\\t', ' ')
except Warning as err:
if debug <= 0:
print(err)
# There is no match for the input message
logger_error.exception(err)
respuesta = 'Ups, parece que ha habido un error 😅Vuelve a intentarlo;'
user_data['runningFunctionality'] = None
user.change_user_data(data['user'], user_data)
except Exception as err:
if debug <= 0:
print(err)
logger_error.exception(err)
respuesta = 'Ups, parece que ha habido un error 😅Vuelve a intentarlo;'
user_data['runningFunctionality'] = None
user.change_user_data(data['user'], user_data)
# It checks the value of the kernel task variable (indicates the function to be performed)
oob = kernel.getPredicate('oob', data['user'])
# If there is a tasks to be performed oob!=null
contador_maximo = 8
while oob and oob != 'null':
try:
add_response = operacion_kernel(oob, kernel, data, logger_error)
except Exception as err:
if debug <= 0:
print(err)
logger_error.exception(err)
respuesta = 'Ups, parece que ha habido un error 😅Vuelve a intentarlo;'
kernel.setPredicate('oob', '', data['user'])
user_data['runningFunctionality'] = None
user.change_user_data(data['user'], user_data)
else:
respuesta = respuesta + add_response
respuesta = respuesta.replace('Uso interno', '')
oob = kernel.getPredicate('oob', data['user'])
contador_maximo = contador_maximo - 1 # To prevent errors
if contador_maximo == 0:
break
if debug <= -1:
print('RESPUESTA KERNEL + OOB: ' + respuesta)
# Log of the response
logger.info('- Origen: Chatbot Destino: ' + data['user'] + ' Message: ' + str(respuesta))
# If the message contains ';' it marks the separation between several messages
# It sends several messages to the user
aux = respuesta.split(';')
token = tokens.server_token().get_tokenDB()
for position, mensaje in enumerate(aux):
# It sends a message to url_message
AppResp['message']['body'] = mensaje
# It only sends here. If there is more than one message, the last one is not sent yet
if position + 1 is not len(aux):
attachment = ''
r = send.do_post(config['url_message'], mensaje, attachment, data)
time.sleep(2)
# The last reply message is generated
AppResp['message']['body'] = urllib.parse.quote(AppResp['message']['body'])
# It obtains the value of the microservice variable from the kernel; used to indicate what
# microservice the user has to run
microservicio = kernel.getPredicate('microservicio', data['user'])
# It changes the user functionality based on the bot response
if microservicio == 'null':
if debug <= 0:
print('Salir del microservicio')
user_data['runningFunctionality'] = None
# It prevents the message from being sent empty
if not AppResp['message']['body']:
AppResp['message']['body'] = 'Vale, salimos.'
else:
user_data['runningFunctionality'] = config['client_id']
# It prevents the message from being sent empty
if not AppResp['message']['body']:
AppResp['message']['body'] = 'Ups, parece que ha habido un error 😅Vuelve a intentarlo'
user_data['runningFunctionality'] = None
if debug <= -5:
print(data)
print(AppResp['message']['body'])
print(AppResp['user'])
# It changes the values of the user in the database
user.change_user_data(data['user'], user_data)
# It generates the response and the headers
resp = app.make_response(json.dumps(AppResp))
if debug <= -5:
print(resp.data)
resp.headers['Access-Control-Allow-Origin'] = '*'
resp.headers['Content-Type'] = 'application/json'
resp.headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
# It sends the response
else:
abort(415, 'Unsupported Media Type')
resp = '415'
print('Unsupported Media Type')
return resp
# It creates a log for connections, which stores a maximum of 60 days
file_handler = logging.handlers.TimedRotatingFileHandler(filename, when='midnight', interval=1, encoding='utf-8',
backupCount=60)
formatter = logging.Formatter('%(asctime)-15s %(levelname)-8s %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# Events log (errors)
logger_error = logging.getLogger('Errors')
fh = logging.handlers.RotatingFileHandler('logs/errors.log', maxBytes=200 * 1024, backupCount=5)
fh.setFormatter(formatter)
logger_error.propagate = False
logger_error.addHandler(fh)
# Authentication token
tokens.server_token().get_token()
# API gateway registration; it keeps trying until it gets an answer
while True:
try:
tokens.server_token().get_token()
# Register in the API gateway
reg = registration.registration()
reg.register()
break
except:
time.sleep(4)
pass
signal.signal(signal.SIGTERM, sigterm_handler)
logger_error.error('Server Starting...')
try:
def DB_device_creation():
#Disposición de Headers
token = tokens.server_token().get_tokenDB()
headers['Authorization'] = 'Bearer ' + token['Data']['id_token']
#Se comprueba si esta creado
##Device
#Petición get a la base de datos
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('GET', config['URL_FHIR']+"Device?identifier:value=Procesado_imagen", headers=headers)
r = conn.getresponse() #776
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation GET Device')
data = json.loads(data)
print(data)
conn.close()
if int(data['total']) != 0:
pass #Si ya está creado no lo vuelve a crear.
else:
#Mensajes a enviar
##Device
payload = {"resourceType": "Device",
#"id": "776", #Se establece id fija (cambiar si está ocupada en el DB)
"identifier": [{ "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}],
"status": "inactive",# active | inactive | entered-in-error | unknown
"type" : { "coding": [{"system": "http://snomed.info/sct",
"code": "701654001",
"display": "Self-care monitoring web-based application software"
}],
"text": "Aplicación móvil de monitoirzación"
},
"version": "1.0",
"contact": [{ "system": "email",
"value": "*****@*****.**",
}],
"url": "https://procesado.ehealthz.es",
"note": [{"authorString" : "Daniel Vicente Moya",
"time" : "2018-04-25T13:52:07+02:00",
"text": "Device en estado de desarrollo y pruebas"
}]
}
payload = json.dumps(payload)
#Petición post a la base de datos para crear recursos
##Device
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('POST', config['URL_FHIR']+"Device", payload, headers)
r = conn.getresponse()
header = r.getheaders()
data = r.read()
print(r.status, r.reason, 'DB_FHIR Creation Device')
data = json.loads(data)
print(data)
conn.close()
#Se comprueba si esta creado
##DeviceMetric
#Petición get a la base de datos
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('GET', config['URL_FHIR']+"DeviceMetric?identifier:value=Procesado_imagen_Metric", headers=headers)
r = conn.getresponse() #777
header = r.getheaders()
#print(header)
data = r.read()
print(r.status, r.reason, 'DB_FHIR Operation GET DeviceMetric')
data = json.loads(data)
print(data)
conn.close()
if int(data['total']) != 0:
pass #Si ya está creado no lo vuelve a crear.
else:
##DeviceMetric
payload2 = {"resourceType" : "DeviceMetric",
#"id": "777", #Se establece id fija (cambiar si está ocupada en el DB)
"identifier" : {"use": "temp",
"value": "Procesado_imagen_Metric",
"assigner": "UNIZAR"
},
"type" : {"coding":[{"system": "urn:iso:std:iso:11073:10101",
"code": "_BSA",
"display": "Body Surface Area"
}],
"text": "Área superficie del cuerpo"
},
"unit" : {"coding":[{"system": "http://unitsofmeasure.org",
"code": "cm2",
"display": "square centimeter"
}],
"text": "centímetros cuadrados"
},
"source" : {"identifier": { "use": "temp",
"value": "Procesado_imagen",
"assigner": "UNIZAR"
}},
#"parent" : {"reference": "Procesado_imagen_Component"},
"operationalStatus" : "off", # on | off | standby | entered-in-error
"color" : "red",
"category" : "measurement"
}
payload2 = json.dumps(payload2)
#Petición post a la base de datos para crear recursos
##DeviceMetric
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
conn = http.client.HTTPSConnection(config['HOSTNAME'], config['PORT'], context=context)
conn.request('POST', config['URL_FHIR']+"DeviceMetric", payload2, headers)
r = conn.getresponse()
header = r.getheaders()
data = r.read()
print(r.status, r.reason, 'DB_FHIR Creation DeviceMetric')
data = json.loads(data)
print(data)
conn.close()
