def __init__(self, nombre_log, servicio_db): self.__cliente_log = Applogging(nombre_log) self.__servicio_db = servicio_db self.__sesion = servicio_db.sesion self.__hilo_datalock = threading.Lock() self.__hilo_cliente_rpi = threading.Thread() self.__comenzar_servicio_background()
class ClienteRPI2: __metaclass__ = Singleton def __init__(self, nombre_log, servicio_db): self.__cliente_log = Applogging(nombre_log) self.__servicio_db = servicio_db self.__sesion = servicio_db.sesion self.__hilo_datalock = threading.Lock() self.__hilo_cliente_rpi = threading.Thread() self.__comenzar_servicio_background() def __comenzar_servicio_background(self): global DEBUG if (DEBUG == False): self.client = mqtt.Client() self.__cliente_log.info_log( f"Configuracion client rpi2 {TOPIC_TEMPERATURA}:{HOSTNAME_SIMULACION_LOCAL}" ) self.client.on_connect = self._on_connect self.client.on_message = self._on_message self.client.connect(HOSTNAME_SIMULACION_LOCAL, 1883, 60) self.__hilo_cliente_rpi = threading.Timer( 0, self.__obtener_datos_cliente_mqtt, ()) self.__cliente_log.info_log( "Servicio cliente mqtt 2 en el background...") self.__hilo_cliente_rpi.start() def __obtener_datos_cliente_mqtt(self): self.__hilo_cliente_rpi = threading.Timer( 0.1, self.__obtener_datos_cliente_mqtt, ()) if (DEBUG == False): self.client.loop_forever() with self.__hilo_datalock: self.__hilo_cliente_rpi.start() def _on_connect(self, client, serdata, flags, rc): global TOPIC_TEMPERATURA self.__cliente_log.info_log( "Conectado como cliente mqtt, con codigo: " + str(rc)) client.subscribe(TOPIC_TEMPERATURA) def _on_message(self, client, userdata, msg): msg.payload = msg.payload.decode("utf-8") mensaje_recibido = msg.payload self.__cliente_log.info_log(msg.topic + " " + mensaje_recibido) mensaje_recibido_json = json.loads(msg.payload) valor_temperatura = mensaje_recibido_json["Temperatura"] self.__insert_medicion_temperatura(temperatura=valor_temperatura) def __insert_medicion_temperatura(self, temperatura): temperatura_ambiente = temperatura[0] self.__sesion = self.__servicio_db.crear_nueva_conexion_si_ha_caducado( ) fecha_actual = datetime.now() self.__cliente_log.info_log(fecha_actual) nueva_medicion = MTemperaturaExterna( fecha=fecha_actual, temperatura_ambiente=temperatura_ambiente) self.__sesion.add(nueva_medicion) self.__sesion.commit()
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 __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 __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 __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 __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 __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()
class ClienteRPI1: __metaclass__= Singleton def __init__(self, nombre_log, servicio_db): self.__cliente_log = Applogging(nombre_log) self.__servicio_db = servicio_db self.__sesion = servicio_db.sesion self.__hilo_datalock = threading.Lock() self.__hilo_cliente_rpi = threading.Thread() self.__comenzar_servicio_background() def __comenzar_servicio_background(self): global DEBUG if (DEBUG == False): self.client = mqtt.Client() self.__cliente_log.info_log(f"Configuracion client rpi1 {TOPIC_ACELEROMETRO}:{HOSTNAME_SIMULACION_LOCAL}") self.client.on_connect = self._on_connect self.client.on_message = self._on_message self.client.connect(HOSTNAME_SIMULACION_LOCAL, 1883, 60) self.__hilo_cliente_rpi = threading.Timer(0, self.__obtener_datos_cliente_mqtt, ()) self.__cliente_log.info_log("Servicio cliente mqtt 1 en el background...") self.__hilo_cliente_rpi.start() def __obtener_datos_cliente_mqtt(self): self.__hilo_cliente_rpi = threading.Timer(0.1, self.__obtener_datos_cliente_mqtt, ()) if (DEBUG == False): self.client.loop_forever() with self.__hilo_datalock: self.__hilo_cliente_rpi.start() def _on_connect(self, client, serdata, flags, rc): global TOPIC_ACELEROMETRO self.__cliente_log.info_log("Conectado como cliente mqtt, con codigo: " + str(rc)) client.subscribe(TOPIC_ACELEROMETRO) def _on_message(self, client, userdata, msg): msg.payload = msg.payload.decode("utf-8") mensaje_recibido = msg.payload self.__cliente_log.info_log(msg.topic + " "+ mensaje_recibido) mensaje_recibido_json = json.loads(msg.payload) varx = mensaje_recibido_json["varx"] vary = mensaje_recibido_json["vary"] varz = mensaje_recibido_json["varz"] self.__insert_medicion_accel( var_x = varx, var_y = vary, var_z = varz) def __insert_medicion_accel(self, var_x, var_y, var_z): self.__sesion = self.__servicio_db.crear_nueva_conexion_si_ha_caducado() fecha_actual = datetime.now() nueva_medicion = MAcelerometro( fecha = fecha_actual, eje_x = var_x, eje_y = var_y, eje_z = var_z,) self.__sesion.add(nueva_medicion) self.__sesion.commit()
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
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_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"])
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"])
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")
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 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")
from servicios.weblogging import Applogging excepcion_import_log = Applogging("Import") def error_gpio_import_log(): return excepcion_import_log.error_log("Error al importar modulo GPIO") def error_mosquito_import_log(): return excepcion_import_log.error_log( "Error al importar modulo paho.mqtt (mosquito)")
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"])
def __init__(self, app): self.__app = app self.__log_startup = Applogging("Startup") self.__acelerometro = RpiLocal()
def __init__(self, app): self.__app = app self.__log_startup = Applogging("Startup") self.__temperatura = RpiLocal()
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 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}" )
def __init__(self, app, _app_ctx_stack): self.__app = app self.__mysql_log = Applogging("MysqlDB") self.engine = None self.sesion = None self.__init_configuracion(_app_ctx_stack)
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()
def __init__(self): self.__pin_ventilador = VENTILADOR_PIN self.__rpi_log = Applogging("RPI")
def __init__(self, servicio_db, sesion): super().__init__(servicio_db, sesion) self.__repositorio_log = Applogging("UsuarioRepo")