TestGenerator DI

"""
Muestra de código generador de datos viejo
"""
class TestGenerator(object):
    """
    Genera datos de pruebas para desarrollo
    """

    def __init__(self, db):
        self.db = db
        self.request = current.request

    def generador_pruebas(self):
        """
        Genera registros de pruebas para todas las tablas del argumento que encuentre sin registros en el sistema
        usando el generador de datos Bayesiano incluido en el framework.
        Genera tambien un conjunto de usuarios de prueba para realizar pruebas de interfaz de usuario y perfiles
        :return: void
        """
        # Inserta los grupos y los usuarios de la base de datos si esta vacía
        self.__grupos()
        self.__usuarios()
        self.__personas()
        self.__sat()
        self.__datoscontacto()
        self.__dependencia()
        self.__direcciones()
        self.__fiscales()  # Aqui truena
        self.__gabinete()
        self.__medicos()
        self.__aranceles()
        # self.__clientes()
        # self.__precios()
        # self.__intermedias()
        self.db.commit()

        # Generador auxiliar - Datos basura. Lo que no llene el anterior se llena aqui
        lista_tablas = self.db.tables()

        # Hardcodeado para remover ordenes de servicio de inserciones "basura"
        lista_tablas.remove('tb_orden_servicio')

        for tabla in lista_tablas:
            if not self.db(self.db[tabla].id > 0).count():
                try:
                    populate.populate(self.db[tabla], 20)
                    self.db.commit()
                except Exception as e:
                    print e.message
        pass

    def __personas(self):
        """
        Genera 100 personas para pruebas y las inserta en los registros de la base de datos
        :return:
        """
        from random import randint

        nombres = ['Juan', 'Pedro', 'Pablo', 'Francisco', 'Jesús', 'Adolfo', 'Gustavo', 'Felipe', 'Alberto', 'Irving',
                   'Adrián', 'Carlos', 'Maria', 'Karla', 'Adriana', 'Karina', 'Elena', 'Alejandra', 'Lucia', 'Ana',
                   'Antonio', 'Edgar', 'Jaime', 'Augusto', 'Marco', 'Tulio', 'Mariana', 'Karina', 'Rubi', 'Esmeralda',
                   'De Jesus', 'Salvadora', 'Catalina'
                   ]

        apellidos = ['Corral', 'Medina', 'Angulo', 'Esquer', 'Gutiérrez', 'López', 'Sánchez', 'Ramírez', 'Valenzuela',
                     'Valencia', 'Barajas', 'Arrecemi', 'Gómez', 'Iñarriatú', 'Garza', 'García', 'Negri', 'Martínez',
                     'Garabito', 'Borrego', 'Peña', 'Nieto', 'Del Campo', 'De la Colina', 'Márquez', 'Maciáca',
                     'Obregón'
                     ]

        sexo = ['Masculino', 'Femenino', 'Transgénero', 'Otro']

        # len() necesita -1, o puede regresar un valor fuera del index de la lista
        for i in range(0, 80):
            self.db.tb_persona.insert(
                apellido_paterno=apellidos[randint(0, len(apellidos) - 1)],
                apellido_materno=apellidos[randint(0, len(apellidos) - 1)],
                nombre=nombres[randint(0, len(nombres) - 1)],
                fecha_nacimiento=self.request.now,
                sexo=sexo[randint(0, len(sexo) - 1)],
                is_active=True,
                created_on=self.request.now,
                created_by=1,
                modified_on=self.request.now,
                modified_by=1,
            )
        pass

    def __usuarios(self):
        """
        Genera usuarios de la base de datos para propósitos de pruebas
        :return:
        """
        if not self.db(self.db.auth_user.id > 0).count():
            recepcionistas_id = self.db(
                self.db.auth_group.role == 'recepcionistas'
            ).select(self.db.auth_group.id)[0].id

            supervisores_id = self.db(
                self.db.auth_group.role == 'supervisores'
            ).select(self.db.auth_group.id)[0].id

            auxiliares_id = self.db(
                self.db.auth_group.role == 'auxiliares'
            ).select(self.db.auth_group.id)[0].id

            finanzas_id = self.db(
                self.db.auth_group.role == 'finanzas'
            ).select(self.db.auth_group.id)[0].id

            administrador_id = self.db(
                self.db.auth_group.role == 'administradores'
            ).select(self.db.auth_group.id)[0].id

            sysadmin_id = self.db(
                self.db.auth_group.role == 'sysadmins'
            ).select(self.db.auth_group.id)[0].id

            import hashlib

            password = hashlib.sha1("123456").hexdigest()

            recep_id = self.db.auth_user.insert(
                first_name="Recepcionista",
                last_name=".",
                email="recepcionista@gmail.com",
                password=password
            )

            super_id = self.db.auth_user.insert(
                first_name="Supervisor",
                last_name=".",
                email="supervisor@gmail.com",
                password=password
            )

            aux_id = self.db.auth_user.insert(
                first_name="Auxiliar",
                last_name=".",
                email="auxiliar@gmail.com",
                password=password
            )

            fin_id = self.db.auth_user.insert(
                first_name="Finanzas",
                last_name=".",
                email="finanzas@gmail.com",
                password=password
            )

            admin_id = self.db.auth_user.insert(
                first_name="Administrador",
                last_name=".",
                email="administrador@gmail.com",
                password=password
            )

            sysad_id = self.db.auth_user.insert(
                first_name="SysAdmin",
                last_name=".",
                email="sysadmin@gmail.com",
                password=password
            )

            self.db.auth_membership.insert(user_id=recep_id,
                                           group_id=recepcionistas_id
                                           )

            self.db.auth_membership.insert(user_id=super_id,
                                           group_id=supervisores_id
                                           )

            self.db.auth_membership.insert(user_id=aux_id,
                                           group_id=auxiliares_id
                                           )

            self.db.auth_membership.insert(user_id=fin_id,
                                           group_id=finanzas_id
                                           )

            self.db.auth_membership.insert(user_id=admin_id,
                                           group_id=administrador_id
                                           )

            self.db.auth_membership.insert(user_id=sysad_id,
                                           group_id=sysadmin_id
                                           )
        return

    def __sat(self):
        if not self.db(self.db.SAT_banco.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_banco.csv')
            csv = open(path)
            self.db.SAT_banco.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_claveprodserv.csv')
            csv = open(path)
            self.db.SAT_claveprodserv.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_claveunidad.csv')
            csv = open(path)
            self.db.SAT_claveunidad.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_formapago.csv')
            csv = open(path)
            self.db.SAT_formapago.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_impuesto.csv')
            csv = open(path)
            self.db.SAT_impuesto.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_metodopago.csv')
            csv = open(path)
            self.db.SAT_metodopago.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_moneda.csv')
            csv = open(path)
            self.db.SAT_moneda.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_regimenfiscal.csv')
            csv = open(path)
            self.db.SAT_regimenfiscal.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_tasaocuota.csv')
            csv = open(path)
            self.db.SAT_tasaocuota.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_tipodecomprobante.csv')
            csv = open(path)
            self.db.SAT_tipodecomprobante.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_tipofactor.csv')
            csv = open(path)
            self.db.SAT_tipofactor.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_tiporelacion.csv')
            csv = open(path)
            self.db.SAT_tiporelacion.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_unidad_medida.csv')
            csv = open(path)
            self.db.SAT_unidad_medida.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_SAT_usocfdi.csv')
            csv = open(path)
            self.db.SAT_usocfdi.import_from_csv_file(csv)
            csv.close()

        return

    def __datoscontacto(self):
        if not self.db(self.db.tb_datos_contacto.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_datos_contacto.csv')
            csv = open(path)
            self.db.tb_datos_contacto.import_from_csv_file(csv)
            csv.close()
        return

    def __dependencia(self):
        if not self.db(self.db.tb_dependencia.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_dependencia.csv')
            csv = open(path)
            self.db.tb_dependencia.import_from_csv_file(csv)
            csv.close()
        return

    def __direcciones(self):
        """
        Incluye todos los elementos de direcciones (municipios, ciudades, estados, etc)
        :return:
        """
        if not self.db(self.db.tb_direccion.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_direccion.csv')
            csv = open(path)
            self.db.tb_direccion.import_from_csv_file(csv)
            csv.close()
        return

    def __fiscales(self):
        if not self.db(self.db.tb_serie.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_serie.csv')
            csv = open(path)
            self.db.tb_serie.import_from_csv_file(csv)
            csv.close()
        if not self.db(self.db.tb_emisor_fiscal.id > 0).count():

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_emisor_fiscal.csv')
            csv = open(path)
            self.db.tb_emisor_fiscal.import_from_csv_file(csv)
            csv.close()
        if not self.db(self.db.tb_receptor_fiscal.id > 0).count():

            # TODO: Problema de llave foranea
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_receptor_fiscal.csv')
            csv = open(path)
            self.db.tb_receptor_fiscal.import_from_csv_file(csv)
            csv.close()
        return

    def __gabinete(self):
        if not self.db(self.db.tb_gabinete.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_gabinete.csv')
            csv = open(path)
            self.db.tb_gabinete.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_sala.csv')
            csv = open(path)
            self.db.tb_sala.import_from_csv_file(csv)
            csv.close()
        return

    def __medicos(self):
        if not self.db(self.db.tb_horario.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_horario.csv')
            csv = open(path)
            self.db.tb_horario.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_especialidad.csv')
            csv = open(path)
            self.db.tb_especialidad.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_staff.csv')
            csv = open(path)
            self.db.tb_staff.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_medico_externo.csv')
            csv = open(path)
            self.db.tb_medico_externo.import_from_csv_file(csv)
            csv.close()
        return

    def __aranceles(self):
        if not self.db(self.db.tb_division.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_division.csv')
            csv = open(path)
            self.db.tb_division.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_placa.csv')
            csv = open(path)
            self.db.tb_placa.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_arancel.csv')
            csv = open(path)
            self.db.tb_arancel.import_from_csv_file(csv)
            csv.close()
        return

    def __clientes(self):
        if not self.db(self.db.tb_cliente.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_cliente.csv')
            csv = open(path)
            self.db.tb_cliente.import_from_csv_file(csv)
            csv.close()
        return

    def __precios(self):
        if not self.db(self.db.tb_descuento.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_descuento.csv')
            csv = open(path)
            self.db.tb_descuento.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_precio.csv')
            csv = open(path)
            self.db.tb_precio.import_from_csv_file(csv)
            csv.close()
        return

    def __intermedias(self):
        if not self.db(self.db.tb_gabinete_usuario.id > 0).count():
            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_gabinete_usuario.csv')
            csv = open(path)
            self.db.tb_gabinete_usuario.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_gabinete_arancel.csv')
            csv = open(path)
            self.db.tb_gabinete_arancel.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_gabinete_banco.csv')
            csv = open(path)
            self.db.tb_gabinete_banco.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_paciente_banco.csv')
            csv = open(path)
            self.db.tb_paciente_banco.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_cliente_banco.csv')
            csv = open(path)
            self.db.tb_cliente_banco.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_cliente_correo.csv')
            csv = open(path)
            self.db.tb_cliente_correo.import_from_csv_file(csv)
            csv.close()

            path = os.path.join(os.path.dirname(__file__), 'catalogos/db_tb_cliente_paciente.csv')
            csv = open(path)
            self.db.tb_cliente_paciente.import_from_csv_file(csv)
            csv.close()
        return