class Temperatura():
def __init__(self):
self.__pin_ventilador = VENTILADOR_PIN
self.__rpi_log = Applogging("RPI")
def medir_temperatura(self):
sensor = DHT(GPIO_sensor)
temperatura = sensor.read()
self.__rpi_log.info_log(temperatura)
return temperatura
def encender_ventilador(self):
try:
GPIO.output(self.__pin_ventilador, GPIO.HIGH)
time.sleep(4)
GPIO.output(self.__pin_ventilador, GPIO.OUT)
except:
self.__rpi_log.error_log("No se ha podido iniciar")
def crear_json(self, tmp):
print("JSON creado")
mensaje = {"Temperatura": tmp}
self.__rpi_log.info_log(mensaje)
mensaje_json = json.dumps(mensaje)
if (publish.single("demotoy/temperatura",
mensaje_json,
hostname=HOSTNAME)):
print("Done")
else:
print("Datos no publicados")
class RpiLocal(metaclass=Singleton):
def __init__(self):
self.__rpi_log = Applogging("RPI")
self.__hilo_datalock = threading.Lock()
self.__hilo_rpi = threading.Thread()
self.__comenzar_servicio_background()
self.__pin_temperatura = TEMP_PIN
self.__servicio_temperatura = None
self.valor_temperatura = None
def __obtener_datos_rpi(self):
try:
self.__hilo_rpi = threading.Timer(SECUANCIA_SEGUNDOS_RPI,
self.__obtener_datos_rpi, ())
self.__servicio_temperatura = Temperatura()
self.__temperatura = self.__servicio_temperatura.medir_temperatura(
)
self.__servicio_temperatura.crear_json(self.__temperatura)
print("La temperatura actual es: {0:.1f}".format(
self.__temperatura))
temp_adecuada = 21
if self.__temperatura < temp_adecuada:
print("Temperatura inferior a la adecuada")
print("Activando sistema de calefacción")
if self.__temperatura > temp_adecuada:
print("Temperatura superior a la adecuada")
print("Activando el sistema de climatización")
# self.__servicio_temperatura.encender_ventilador()
GPIO.cleanup()
except:
self.__rpi_log.error_log("No se ha podido obtener datos de la rpi")
self.__servicio_temperatura = Temperatura()
self.__temperatura = self.devolver_datos_fake()
with self.__hilo_datalock:
self.__hilo_rpi.start()
def __comenzar_servicio_background(self):
try:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.__pin_temperatura, GPIO.OUT)
except:
self.__rpi_log.error_log(
"No se han podido configurar las salidas GPIO")
self.__hilo_rpi = threading.Timer(0, self.__obtener_datos_rpi, ())
self.__rpi_log.info_log("Servicio RPI comenzando en background")
self.__hilo_rpi.start()
def devolver_datos_fake(self):
temp = randrange(25)
return {'Temperatura': temp}
class RpiLocal(metaclass=Singleton):
def __init__(self):
self.__rpi_log = Applogging("RPI")
self.__hilo_datalock = threading.Lock()
self.__hilo_rpi = threading.Thread()
self.__pin_ventilador = VENTILADOR_PIN
self.__comenzar_servicio_background()
def __obtener_datos_rpi(self):
self.crear_envar_json()
try:
self.__hilo_rpi = threading.Timer(SECUANCIA_SEGUNDOS_RPI, self.__obtener_datos_rpi, ())
except:
self.__rpi_log.error_log("No se ha podido obtener datos de la rpi")
with self.__hilo_datalock:
self.__hilo_rpi.start()
def __comenzar_servicio_background(self):
try:
self.__acelerometro = Acelerometro()
self.__acelerometro.mode_config()
time.sleep(0.1)
self.__acelerometro.sample_rate_config()
time.sleep(0.1)
self.__acelerometro.interrupt_config()
time.sleep(0.1)
except:
self.__rpi_log.error_log("No se han podido configurar las salidas GPIO")
self.__hilo_rpi = threading.Timer(0, self.__obtener_datos_rpi, ())
self.__rpi_log.info_log("Servicio RPI comenzando en background")
self.__hilo_rpi.start()
def crear_envar_json(self):
global topic
global HOSTNAME
print("Creado json")
accl = self.__acelerometro.read_accl()
eje_x = accl['x']
eje_y = accl['y']
eje_z = accl['z']
mensaje= {
"varx": eje_x,
"vary": eje_y,
"varz": eje_z
}
mensaje_json= json.dumps(mensaje)
print(mensaje_json + topic + HOSTNAME)
if (publish.single(topic, mensaje_json, hostname=HOSTNAME)):
print("Done")
else:
print("Datos no publicados")
class Autenticacion(metaclass=Singleton):
def __init__(self, servicio_db):
self.__autenticacion_log = Applogging("Autenticacion")
self.servicio_db = servicio_db
self.__sesion = servicio_db.sesion
self.usuario_autenticado = False
self.ultima_autenticacion = None
def crear_usuario(self, nombre_form, email_form, contrasenia_form) -> bool:
try:
self.__sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
if (self.__sesion.query(
exists().where(Usuario.nombre == nombre_form)).scalar()):
self.__autenticacion_log.warning_log(
f"El usuario con nombre {nombre_form} ya existe")
return False
else:
nuevo_usuario = Usuario(nombre_form, email_form,
contrasenia_form)
self.__sesion.add(nuevo_usuario)
self.__sesion.commit()
return True
except:
self.__autenticacion_log.error_log(
"Ha habido un problema para crear usuario")
return False
def comprobar_autenticacion(self, nombre_form, contrasenia_form) -> bool:
try:
self.__sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
if (self.__sesion.query(
exists().where(Usuario.nombre == nombre_form)).scalar()):
usuario = self.__sesion.query(Usuario).filter_by(
nombre=nombre_form).first()
self.__sesion.commit()
if (usuario.get_contrasenia() != contrasenia_form):
self.__autenticacion_log.warning_log(
f"El usuario con nombre {nombre_form} existe pero las credenciales no son correctas"
)
return self.usuario_autenticado
elif (usuario.get_contrasenia() == contrasenia_form):
self.usuario_autenticado = True
self.__autenticacion_log.info_log("Usuario autenticado")
self.ultima_autenticacion = time.time()
return self.usuario_autenticado
else:
self.__autenticacion_log.warning_log(
f"El usuario con nombre {nombre_form} no existe")
return self.usuario_autenticado
except:
self.__autenticacion_log.error_log(
"Ha habido un problema con la autenticacion")
class RepositorioBase(IRepositorioBase, Generic[T]):
def __init__(self, servicio_db, sesion):
self.servicio_db = servicio_db
self.sesion = sesion
self.__base_log = Applogging("RepositorioBase")
def obtener_todo(self) -> [T]:
try:
self.sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
entidades = self.seion.query(T).filter_by().all()
self.sesion.commit()
return entidades
except Exception:
self.__base_log.error_log(
f"No se han podido obtener las entidades de tipo {T}")
return None
def obtener_entidad(self, entidad: T) -> T:
try:
self.sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
entidad = self.esion.query(T).filter_by(T.id == entidad.id).first()
self.sesion.commit()
return entidad
except Exception:
self.__base_log.error_log(
f"No se ha podido obtener la entidad {entidad}")
return None
async def task_insertar_entidad(self, entidad: T) -> bool:
try:
self.sesion = await self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
await self.sesion.add(entidad)
await self.sesion.commit()
return True
except Exception:
self.__base_log.error_log(
f"No se han podido insertar la entidad {entidad}")
return False
def eliminar_entidad(self, entidad: T) -> bool:
try:
self.sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
self.sesion.query(T).filter_by(T.id == entidad.id).delete(
synchronize_session='evaluate')
self.sesion.commit()
return True
except Exception:
self.__base_log.error_log(
f"No se han podido eliminar la entidad {entidad}")
return False
class RpiLocal(metaclass=Singleton):
def __init__(self):
self.__rpi_log = Applogging("RPI")
self.__hilo_datalock = threading.Lock()
self.__hilo_rpi = threading.Thread()
self.__pin_buzzer = BUZZER_PIN
self.temperatura_cpu = None
self.parpadear = True
self.__comenzar_servicio_background()
def pitar_buzzer(self):
try:
GPIO.output(self.__pin_buzzer, GPIO.HIGH)
time.sleep(1)
GPIO.output(self.__pin_buzzer, GPIO.OUT)
except:
self.__rpi_log.error_log("No se ha podido pitar")
def __obtener_datos_rpi(self):
try:
self.__hilo_rpi = threading.Timer(SECUANCIA_SEGUNDOS_RPI,
self.__obtener_datos_rpi, ())
self.__medir_temperatura_interna()
if (self.temperatura_cpu > 40 and self.parpadear == True):
self.__parpadear_led()
else:
self.__dejar_parpadear()
except:
self.__rpi_log.error_log("No se ha podido obtener datos de la rpi")
with self.__hilo_datalock:
self.__hilo_rpi.start()
def __comenzar_servicio_background(self):
try:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.__pin_buzzer, GPIO.OUT)
except:
self.__rpi_log.error_log(
"No se han podido configurar las salidas GPIO")
self.__hilo_rpi = threading.Timer(0, self.__obtener_datos_rpi, ())
self.__rpi_log.info_log("Servicio RPI comenzando en background")
self.__hilo_rpi.start()
def __medir_temperatura_interna(self):
cpu = subprocess.check_output(
'sudo cat /sys/class/thermal/thermal_zone0/temp', shell=True)
self.temperatura_cpu = int(
cpu
) / 1000 # Se divide en en 1000 por que muestra decimales, ej; 48320
self.__rpi_log.info_log(f"Temperatura CPU: {self.temperatura_cpu}")
def __parpadear_led(self):
os.system('modprobe ledtrig_heartbeat')
resultado = os.system('echo heartbeat >/sys/class/leds/led0/trigger')
return resultado
def __dejar_parpadear(self):
os.system('echo 0 >/sys/class/leds/led0/brightness')
self.__rpi_log.info_log("Dejando de parpadear")
class MysqlDB(metaclass=Singleton):
def __init__(self, app, _app_ctx_stack):
self.__app = app
self.__mysql_log = Applogging("MysqlDB")
self.__server_ssh = None
self.engine = None
self.sesion = None
self.__iniciar_instancias_conexiones(_app_ctx_stack)
def crear_nueva_conexion_si_ha_caducado(self):
try:
self.sesion.rollback()
id = self.engine.execute(
"SELECT id FROM domotoyawsdatabase.usuario").first()
return self.sesion
except Exception:
self.__mysql_log.warning_log(
"La sesion ha caducado o ha habido un problema inesperado")
self.__server_ssh = self.__crear_tunel_ssh()
self.__crear_conexion_demotoy_database()
self.__mysql_log.info_log("Se ha establecido una nueva conexion")
return self.sesion
def __iniciar_instancias_conexiones(self, _app_ctx_stack):
try:
puerto_socket_ssh = self.__iniciar_ssh()
self.__iniciar_mysql(puerto_socket_ssh)
except Exception:
self.__mysql_log.error_log(
"No se han podido iniciar las instancias de la conexion")
self.__mysql_log.info_log(
"Inciando conexion con una base de datos local")
self.__iniciar_mysql("3306")
except Exception:
self.__mysql_log.error_log(
"No se han podido iniciar las instancias de la conexion")
def __iniciar_ssh(self) -> str:
self.__obtener_direccion_remota_ssh()
self.__server_ssh = self.__crear_tunel_ssh()
puerto_socket_ssh = str(self.__server_ssh.local_bind_port)
return puerto_socket_ssh
def __obtener_direccion_remota_ssh(self) -> str:
global SSH_IP_REMOTA, SSH_PUERTO, SSH_NOMBRE_USUARIO, SSH_PRIVATE_KEY_PATH
try:
with open("awsserversettings.json") as server_settings_json:
datos = json.load(server_settings_json)
for configuracion in datos['ssh-settings']:
SSH_IP_REMOTA = configuracion['host-remote']
SSH_PUERTO = configuracion['port']
SSH_NOMBRE_USUARIO = configuracion['server-user']
SSH_PRIVATE_KEY_PATH = configuracion['private-key']
except Exception:
self.__mysql_log.error_log(
"No se ha podido obtener las credenciales de servidor remoto")
def __crear_tunel_ssh(self) -> SSHTunnelForwarder:
try:
server = SSHTunnelForwarder(
(SSH_IP_REMOTA, SSH_PUERTO),
ssh_username=SSH_NOMBRE_USUARIO,
ssh_pkey=SSH_PRIVATE_KEY_PATH,
remote_bind_address=(MYSQL_IP_LOCAL, MYSQl_PUERTO),
)
self.__mysql_log.info_log(
f"Utilizando la direccion remota {SSH_IP_REMOTA}:{SSH_PUERTO} con IP host servidor {MYSQL_IP_LOCAL}:{MYSQl_PUERTO}"
)
server.start()
return server
except Exception:
self.__mysql_log.error_log(
"No se han podido establecer la conexion ssh")
def __iniciar_mysql(self, puerto_socket_ssh):
self.__cadena_conexion = self.__obtener_direcion_remota_mysql(
puerto_socket_ssh)
self.__mysql_log.info_log(
f"Utilizando direccion mysql mediante ssh: {self.__cadena_conexion}"
)
self.engine = create_engine(self.__cadena_conexion, pool_pre_ping=True)
self.__crear_conexion_demotoy_database()
def __obtener_direcion_remota_mysql(self, puerto_socket_ssh) -> str:
global MYSQL_IP_LOCAL, MYSQL_USER, MYSQL_CONTRASENIA, MYSQl_PUERTO, MYSQL_NOMBRE_DB, PUERTO_SOCKET_LOCAL
try:
PUERTO_SOCKET_LOCAL = puerto_socket_ssh
cadena_conexion = None
with open("awsserversettings.json") as server_settings_json:
datos = json.load(server_settings_json)
self.__mysql_log.info_log(datos)
for configuracion in datos['mysql-server-settings']:
MYSQL_IP_LOCAL = configuracion['host-local']
MYSQL_USER = configuracion['admin-user']
MYSQL_CONTRASENIA = configuracion['password']
MYSQl_PUERTO = configuracion['mysql-port']
MYSQL_NOMBRE_DB = configuracion['db']
cadena_conexion = self.__crear_cadena_conexion(
MYSQL_USER, MYSQL_CONTRASENIA, MYSQL_IP_LOCAL,
PUERTO_SOCKET_LOCAL, MYSQL_NOMBRE_DB)
return cadena_conexion
except Exception:
self.__mysql_log.error_log(
"No se ha podido obtener las credenciales de servidor remoto")
def __crear_cadena_conexion(self, usuario, contrasenia, ip_local,
puerto_socket, base_de_datos):
return f"mysql+mysqldb://{usuario}:{contrasenia}@{ip_local}:{puerto_socket}/{base_de_datos}"
def __crear_conexion_demotoy_database(self):
global MYSQL_NOMBRE_DB
try:
self.engine.connect()
Session = sessionmaker(autocommit=False,
autoflush=False,
bind=self.engine)
self.sesion = Session()
except Exception:
self.__mysql_log.error_log(
"Error al intentar crear la conexión con la base de datos: {MYSQL_NOMBRE_DB}"
)
class Startup:
def __init__(self, app):
self.__app = app
self.__log_startup = Applogging("Startup")
self.servicio_db = None
self.servicio_autenticacion = None
self.servicio_rpi = None
self.__inyeccion_dependencias()
def __inyeccion_dependencias(self):
self.__log_startup.info_log("Iniciando instacias de la aplicacion")
self.__add_servicio_db()
self.__add_servicio_autenticacion()
self.__add_servicio_rpi()
def __add_servicio_db(self):
try:
self.__log_startup.info_log("Iniciando servicio mysql...")
self.servicio_db = MysqlDB(self.__app, _app_ctx_stack)
self.__log_startup.info_log("Creando tablas")
usuario.Base.metadata.create_all(bind=self.servicio_db.engine)
self.servicio_db.sesion.commit()
except:
self.__log_startup.error_log("Error a la hora de crear tablas")
def __add_servicio_autenticacion(self):
self.__log_startup.info_log("Iniciando servicio autenticacion...")
self.servicio_autenticacion = Autenticacion(self.servicio_db)
index_controller_log = Applogging("Controlador Index")
self.__app.add_url_rule('/',
endpoint='index',
view_func=Indexcontroller.as_view(
'index',
autenticacion=self.servicio_autenticacion,
index_controller_log=index_controller_log),
methods=["GET", "POST"])
registro_controller_log = Applogging("Controlador Registro")
self.__app.add_url_rule(
'/registro',
endpoint='registro',
view_func=Registrocontroller.as_view(
'registro',
autenticacion=self.servicio_autenticacion,
registro_controller_log=registro_controller_log),
methods=["GET", "POST"])
def __add_servicio_rpi(self):
self.__log_startup.info_log("Iniciando servicio rpi...")
self.servicio_rpi = Rpi()
principal_controller_log = Applogging("Controlador Principal")
self.__app.add_url_rule(
'/principal',
endpoint='principal',
view_func=Principalcontroller.as_view(
'principal',
autenticacion=self.servicio_autenticacion,
rpi=self.servicio_rpi,
principal_controller_log=principal_controller_log),
methods=["GET", "POST"])
class Autenticacion(metaclass=Singleton):
def __init__(self, servicio_db):
self.__autenticacion_log = Applogging("Autenticacion")
self.servicio_db = servicio_db
self.__sesion = servicio_db.sesion
self.usuario_autenticado = False
self.ultima_autenticacion = None
self.usuario = None
def crear_usuario(self, modelo_nuevo_usuario: CrearModeloUsuario) -> bool:
try:
self.__sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
if (self.__usuario_existe(modelo_nuevo_usuario.nombre)):
return False
else:
modelo_nuevo_usuario = Usuario(
nombre=modelo_nuevo_usuario.nombre,
email=modelo_nuevo_usuario.email,
contrasenia=modelo_nuevo_usuario.contrasenia,
nombre_completo=modelo_nuevo_usuario.nombre_completo,
numero_telefono=modelo_nuevo_usuario.numero_telefono,
direccion=modelo_nuevo_usuario.direccion)
self.__sesion.add(modelo_nuevo_usuario)
self.__sesion.commit()
return True
except:
self.__autenticacion_log.error_log(
"Ha habido un problema para crear usuario")
return False
def comprobar_autenticacion(self,
modelo_auth: ComprobarModeloUsuario) -> bool:
try:
self.__sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
if (self.__usuario_existe(modelo_auth.nombre)):
usuario_existente = self.__obtener_usuario(modelo_auth.nombre)
self.__sesion.commit()
self.__comprobar_credenciales(usuario_existente,
modelo_auth.nombre,
modelo_auth.contrasenia)
return self.usuario_autenticado
else:
self.__autenticacion_log.warning_log(
f"El usuario con nombre {modelo_auth.nombre} no existe")
return self.usuario_autenticado
except:
self.__autenticacion_log.error_log(
"Ha habido un problema con la autenticacion")
def __usuario_existe(self, nombre_form) -> bool:
if (self.__sesion.query(
exists().where(Usuario.nombre == nombre_form)).scalar()):
self.__autenticacion_log.info_log(
f"El usuario con nombre {nombre_form} existe")
return True
else:
return False
def __obtener_usuario(self, nombre_form: str):
usuario = self.__sesion.query(Usuario).filter_by(
nombre=nombre_form).first()
return usuario
def __comprobar_credenciales(self, usuario_existente: Usuario,
nombre_form: str, contrasenia_form: str):
if (usuario_existente.get_contrasenia() != contrasenia_form):
self.__autenticacion_log.warning_log(
f"El usuario con nombre {nombre_form} existe pero las credenciales no son correctas"
)
elif (usuario_existente.get_contrasenia() == contrasenia_form):
self.__estado_autenticado_true(usuario_existente)
def __estado_autenticado_true(self, usuario_existente: Usuario):
self.usuario_autenticado = True
self.usuario = usuario_existente
self.__autenticacion_log.info_log("Usuario autenticado")
self.ultima_autenticacion = time.time()
class RepositorioUsuario(RepositorioBase[Usuario]):
def __init__(self, servicio_db, sesion):
super().__init__(servicio_db, sesion)
self.__repositorio_log = Applogging("UsuarioRepo")
def obtener_usuario(self, nombre: str) -> CrudResultT[Usuario]:
try:
self.sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
usuario = self.sesion.query(Usuario).filter_by(
Usuario.nombre == nombre).first()
self.sesion.commit()
if (usuario == None):
self.__repositorio_log.warning_log(
f"El suaurio con nombre:{nombre} no fue encontrado")
return crudResultT.not_found()
else:
self.__repositorio_log.info_log(
f"El suaurio con nombre:{nombre} no fue encontrado")
return crudResultT.success(usuario)
except Exception:
self.__repositorio_log.error_log(
f"No se han podido obtener la entidad con nombre:{nombre}")
return crudResultT.error()
def obtener_usuarios(self) -> list:
usuarios = self.obtener_todo()
if (usuarios == None):
self.__repositorio_log.error_log("No se han encontrado usuarios")
return crudResultT.not_found()
else:
self.__repositorio_log.error_log("Obteniendo todos los suarios")
return crudResultT.success(usuarios)
async def task_crear_usuario(self, usuario: Usuario) -> CrudResult:
if (await self.sesion.query(
exists().where(Usuario.nombre == usuario.nombre)).scalar()):
self.__repositorio_log.warning_log(
f"El suaurio {usuario.nombre} ya existe")
return crudResult.error()
else:
self.__repositorio_log.info_log(
f"El suaurio {usuario.nombre} no existe")
resultado = await self.task_insertar_entidad(usuario)
if (resultado):
crudResult.success()
else:
return crudResult.error()
def eliminar_usuario(self, usuario: Usuario) -> CrudResult:
try:
self.sesion = self.servicio_db.crear_nueva_conexion_si_ha_caducado(
)
if (self.sesion.query(
exists().where(Usuario.id == usuario.id)).scalar()):
self.sesion.query(Usuario).filter_by(
Usuario.id == usuario.id).delete(
synchronize_session='evaluate')
self.sesion.commit()
return crudResult.success()
else:
return crudResult.not_found()
except Exception:
self.__repositorio_log.error_log(
f"No se han podido eliminar la entidad {usuario}")
return crudResult.error()
class Startup:
def __init__(self, app):
self.__app = app
self.__log_startup = Applogging("Startup")
self.__servicio_db = None
self.__servicio_autenticacion = None
self.__repositorio_usuario = None
self.__servicioRPi1 = None
self.__servicioRPi2 = None
self.__servicio_rpi_local = None
self.__api = None
self.__inyeccion_servicios()
def __inyeccion_servicios(self):
self.__log_startup.info_log("Iniciando instacias de la aplicacion")
self.__add_servicio_db()
self.__add_repositorios()
self.__add_servicio_autenticacion()
self.__add_servicio_cliente_rpi1()
self.__add_servicio_cliente_rpi2()
self.__add_servicio_principal()
self.__add_servicio_monitorizacion()
def __add_servicio_db(self):
self.__log_startup.info_log("Iniciando servicio mysql...")
self.__servicio_db = MysqlDB(self.__app, _app_ctx_stack)
self.sesion = self.__servicio_db.sesion
self.__crear_tablas()
def __crear_tablas(self):
try:
self.__log_startup.info_log("Creando tablas")
usuario.Base.metadata.create_all(bind=self.__servicio_db.engine)
medicionTempemperaturaInterna.Base.metadata.create_all(
bind=self.__servicio_db.engine)
medicionTempemperaturaExterna.Base.metadata.create_all(
bind=self.__servicio_db.engine)
medicionAccelerometro.Base.metadata.create_all(
bind=self.__servicio_db.engine)
self.sesion.commit()
except:
self.__log_startup.error_log("Error a la hora de crear tablas")
def __add_repositorios(self):
self.__repositorio_usuario = RepositorioUsuario(
self.__servicio_db, self.sesion)
def __add_servicio_autenticacion(self):
self.__log_startup.info_log("Iniciando servicio autenticacion...")
self.__servicio_autenticacion = Autenticacion(self.__servicio_db)
self.__add_index_controller()
self.__add_registro_controller()
def __add_index_controller(self):
index_controller_log = Applogging("Controlador Index")
self.__app.add_url_rule(
'/',
endpoint='index',
view_func=Indexcontroller.as_view(
'index',
autenticacion=self.__servicio_autenticacion,
index_controller_log=index_controller_log),
methods=["GET", "POST"])
def __add_registro_controller(self):
registro_controller_log = Applogging("Controlador Registro")
self.__app.add_url_rule(
'/registro',
endpoint='registro',
view_func=Registrocontroller.as_view(
'registro',
repositorio_usuario=self.__repositorio_usuario,
registro_controller_log=registro_controller_log),
methods=["GET", "POST"])
def __add_servicio_cliente_rpi1(self):
self.__log_startup.info_log("Iniciando servicio cliente RPi1..")
nombre_log = "RPI1"
self.__servicioRPi1 = ClienteRPI1(nombre_log=nombre_log,
servicio_db=self.__servicio_db)
def __add_servicio_cliente_rpi2(self):
self.__log_startup.info_log("Iniciando servicio cliente RPi2..")
nombre_log = "RPI2"
self.__servicioRPi2 = ClienteRPI2(nombre_log=nombre_log,
servicio_db=self.__servicio_db)
def __add_servicio_principal(self):
self.__log_startup.info_log("Iniciando servicio rpi local y api...")
self.__servicio_rpi_local = RpiLocal()
self.__api = Api(servicio_db=self.__servicio_db)
self.__add_principal_controller()
def __add_principal_controller(self):
principal_controller_log = Applogging("Controlador Principal")
self.__app.add_url_rule(
'/principal',
endpoint='principal',
view_func=Principalcontroller.as_view(
'principal',
autenticacion=self.__servicio_autenticacion,
rpi_local=self.__servicio_rpi_local,
principal_controller_log=principal_controller_log,
api=self.__api),
methods=["GET", "POST", "PUT"])
def __add_servicio_monitorizacion(self):
self.__log_startup.info_log("Iniciando servicio monitorizacion..")
self.__add_monitorizacion_controller()
def __add_monitorizacion_controller(self):
monitorizacion_controller_log = Applogging("Controlador Principal")
self.__app.add_url_rule(
'/monitorizacion',
endpoint='monitorizacion',
view_func=Monitorizacioncontroller.as_view(
'monitorizacion',
autenticacion=self.__servicio_autenticacion,
monitorizacion_controller_log=monitorizacion_controller_log,
api=self.__api),
methods=["GET", "POST"])
