empresa-libre/source/app/models/main.py

#!/usr/bin/env python

import sqlite3
import click
from peewee import *
from playhouse.fields import PasswordField, ManyToManyField


if __name__ == '__main__':
    import os, sys
    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.insert(0, parent_dir)


from controllers import util
from conf import DATABASE, __version__
from settings import log, PATH_CP


database = DATABASE
class BaseModel(Model):
    class Meta:
        database = database


def conectar():
    global database
    database.connect()
    log.info('Conectado a la BD...')
    return


class Configuracion(BaseModel):
    clave = TextField()
    valor = TextField()

    class Meta:
        order_by = ('clave',)
        indexes = (
            (('clave', 'valor'), True),
        )


class Tags(BaseModel):
    tag = TextField(index=True, unique=True)

    class Meta:
        order_by = ('tag',)


class Usuarios(BaseModel):
    usuario = TextField(unique=True)
    nombre = TextField(default='')
    apellidos = TextField(default='')
    correo = TextField(default='')
    contraseña = PasswordField()
    es_superusuario = BooleanField(default=False)
    es_admin = BooleanField(default=False)
    es_activo = BooleanField(default=True)
    fecha_ingreso = DateTimeField(default=util.now)
    ultimo_ingreso = DateTimeField(null=True)

    def __str__(self):
        t = '{} {} ({})'
        return t.format(self.nombre, self.apellidos, self.usuario)

    class Meta:
        order_by = ('nombre', 'apellidos')


class SATRegimenes(BaseModel):
    key = TextField(index=True, unique=True)
    name = TextField(index=True)
    activo = BooleanField(default=False)
    default = BooleanField(default=False)
    fisica = BooleanField(default=False)
    moral = BooleanField(default=False)

    class Meta:
        order_by = ('name',)
        indexes = (
            (('key', 'name'), True),
        )


class Emisor(BaseModel):
    rfc = TextField(index=True)
    nombre = TextField()
    codigo_postal = TextField(default='')
    moral = BooleanField(default=False)
    regimenes = ManyToManyField(SATRegimenes, related_name='emisores')

    def __str__(self):
        t = '{} ({})'
        return t.format(self.nombre, self.rfc)

    class Meta:
        order_by = ('nombre',)


class Certificado(BaseModel):
    key = BlobField()
    key_enc = TextField(default='')
    cer = BlobField()
    cer_pem = TextField(default='')
    cer_txt = TextField(default='')
    p12 = BlobField()
    serie = TextField(default='')
    rfc = TextField(default='')
    desde = DateTimeField()
    hasta = DateTimeField()

    def __str__(self):
        return self.serie


class Clients(BaseModel):
    person_type = IntegerField(default=0)
    rfc = FixedCharField(max_length=13, index=True)
    name = CharField(max_length=1000, index=True)
    street = FixedCharField(max_length=200, default='')
    num_ext = FixedCharField(max_length=25, default='')
    num_int = FixedCharField(max_length=25, default='')
    postal_code = FixedCharField(max_length=15, default='')
    colonia = FixedCharField(max_length=100, default='')
    municipio = FixedCharField(max_length=100, default='')
    state = FixedCharField(max_length=100, default='')
    country = FixedCharField(max_length=100, default='')
    conditions_pay = FixedCharField(max_length=250, default='')
    days_pay = IntegerField(default=0)
    business_days = BooleanField(default=False)
    is_active = BooleanField(default=True)
    commercial_name = CharField(max_length=1000, default='')
    phones = CharField(max_length=500, default='')
    web_page = CharField(max_length=500, default='')
    invoice_email = CharField(max_length=500, default='')
    is_client = BooleanField(default=False)
    is_supplier = BooleanField(default=False)
    is_ong = BooleanField(default=False)
    account_client = FixedCharField(max_length=100, default='')
    account_supplier = FixedCharField(max_length=100, default='')
    notes = CharField(max_length=5000)

    def __str__(self):
        t = '{} ({})'
        return t.format(self.name, self.rfc)

    class Meta:
        order_by = ('name',)
        indexes = (
            (('rfc', 'name'), True),
        )


class ClientsTags(BaseModel):
    client = ForeignKeyField(Clients)
    tag = ForeignKeyField(Tags)

    class Meta:
        indexes = (
            (('client', 'tag'), True),
        )


def authenticate(usuario, contraseña):
    respuesta = {'login': False, 'msg': 'No Autorizado', 'user': ''}
    try:
        obj = Usuarios.get(usuario=usuario, es_activo=True)
    except Usuarios.DoesNotExist:
        return respuesta

    if not obj.contraseña.check_password(contraseña):
        return respuesta

    obj.ultimo_ingreso = util.now()
    obj.save()
    respuesta['msg'] = ''
    respuesta['login'] = True
    respuesta['user'] = str(obj)
    respuesta['super'] = obj.es_superusuario
    return respuesta


def get_partners(values):
    if values:
        id = int(values['id'])
        row = Clients.select().where(Clients.id==id).dicts()[0]
        return row

    rows = Clients.select(Clients.id, Clients.rfc, Clients.name).dicts()
    return {'ok': True, 'rows': tuple(rows)}


def new_partner(values):
    fields = util.clean(values)
    fields['rfc'] = fields['rfc'].upper()
    obj = Clients.create(**fields)
    row = {
        'id': obj.id,
        'cia': obj.cia,
        'rfc': obj.rfc,
        'name': obj.name,
    }
    data = {'ok': True, 'row': row, 'new': True}
    return data


def get_cp(cp):
    con = sqlite3.connect(PATH_CP)
    cursor = con.cursor()
    sql = """
        SELECT colonia, municipio, estado
        FROM colonias, municipios, estados
        WHERE colonias.id_municipio=municipios.id
            AND municipios.id_estado=estados.id
            AND cp=?
        ORDER BY colonia"""
    cursor.execute(sql, (cp,))
    rows = cursor.fetchall()
    cursor.close()
    con.close()

    data = {}
    if rows:
        data = {
            'estado': rows[0][2],
            'municipio': rows[0][1],
        }
        if len(rows) == 1:
            data['colonia'] = rows[0][0]
        else:
            data['colonia'] = [r[0] for r in rows]
    return data


def _init_values():
    data = (
        {'key': 'version', 'value': __version__},
        {'key': 'rfc_publico', 'value': 'XAXX010101000'},
        {'key': 'rfc_extranjero', 'value': 'XEXX010101000'},
    )
    for row in data:
        try:
            Configuration.create(**row)
        except IntegrityError:
            pass
    log.info('Valores iniciales insertados...')
    return


def _crear_tablas():
    conectar()
    tablas = [Configuracion, Tags, Usuarios,
        Certificado, Emisor, Emisor.regimenes.get_through_model()]
    database.create_tables(tablas, True)
    log.info('Tablas creadas correctamente...')
    return


def migrate_tables():
    connect()
    log.info('Tablas migradas correctamente...')
    return


def _agregar_superusuario():
    conectar()
    usuario = input('Introduce el nuevo nombre para el superusuario: ').strip()
    if not usuario:
        msg = 'El nombre de usuario es requerido'
        log.erro(msg)
        return
    ok, contraseña = util.get_pass()
    if not ok:
        log.error(contraseña)
        return
    try:
        obj = Usuarios.create(
            usuario=usuario, contraseña=contraseña, es_superusuario=True)
    except IntegrityError:
        msg = 'El usuario ya existe'
        log.error(msg)
        return

    log.info('SuperUsuario creado correctamente...')
    return


def _cambiar_contraseña():
    conectar()
    usuario = input('Introduce el nombre de usuario: ').strip()
    if not usuario:
        msg = 'El nombre de usuario es requerido'
        log.error(msg)
        return

    try:
        obj = Usuarios.get(usuario=usuario)
    except Usuarios.DoesNotExist:
        msg = 'El usuario no existe'
        log.error(msg)
        return

    ok, contraseña = util.get_pass()
    if not ok:
        log.error(contraseña)
        return

    obj.contraseña = contraseña
    obj.save()

    log.info('Contraseña cambiada correctamente...')
    return


CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
help_create_tables = 'Crea las tablas en la base de datos'
help_migrate_db = 'Migra las tables en la base de datos'
help_superuser = 'Crea un nuevo super usuario'
help_change_pass = 'Cambia la contraseña a un usuario'

@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('-bd', '--iniciar-bd',help=help_create_tables,
    is_flag=True, default=False)
@click.option('-m', '--migrar-bd', help=help_migrate_db,
    is_flag=True, default=False)
@click.option('-ns', '--nuevo-superusuario', help=help_superuser,
    is_flag=True, default=False)
@click.option('-cc', '--cambiar-contraseña', help=help_change_pass,
    is_flag=True, default=False)
def main(iniciar_bd, migrar_bd, nuevo_superusuario, cambiar_contraseña):
    opt = locals()

    if opt['iniciar_bd']:
        _crear_tablas()
        sys.exit(0)

    if opt['migrar_bd']:
        migrate_tables()
        sys.exit(0)

    if opt['nuevo_superusuario']:
        _agregar_superusuario()
        sys.exit(0)

    if opt['cambiar_contraseña']:
        _cambiar_contraseña()
    return


if __name__ == '__main__':
    main()