Esempio n. 1
0
class Comptes(db.Model):
    id_compte = db.Column(db.String(50), primary_key=True)
    id_client = db.Column(db.String(50), db.ForeignKey('client.username'))
    type_compte = db.Column(db.Enum(TypeCompte))
    rib = db.Column(db.String(50))
    solde = db.Column(db.Float(20))
    date_creation = db.Column(db.Date)

    @classmethod
    def creation_compteban(cls, id_client):
        client = User.query.get(id_client)
        if client is not None:
            this_comtpe = Comptes(
                id_compte=(random.randint(1000000000, 9999999999)),
                type_compte='COURANT',
                date_creation=str(date.today()),
                rib=str(random.randint(1000000000, 9999999999)),
                solde=0.0,
                id_client=id_client)
            User.populate(this_comtpe)
        else:
            flash(_l("Insertion Problem"))

    def solvabilite(self, valeur_virement=0):
        return self.sode >= valeur_virement
Esempio n. 2
0
class Entidade(db.Model):
    __tablename__ = 'entidades'

    entidade_id = db.Column(db.Integer, primary_key=True)
    nome = db.Column(db.String(), nullable=False)
    tipo_pessoa = db.Column(db.Enum(TipoPessoa))
    url_entidade = db.Column(db.String())
    descricao = db.Column(db.String())

    def __init__(self, nome, tipo_pessoa, url_entidade, descricao):
        self.nome = nome
        self.tipo_pessoa = tipo_pessoa
        self.url_entidade = url_entidade
        self.descricao = descricao

    def __repr__(self):
        return '<Entidade: %r>' % self.nome

    def serialize(self):
        tipo_p = None
        if self.tipo_pessoa:
            tipo_p = self.tipo_pessoa.value
        return {
            'entidade_id': self.entidade_id,
            'nome': self.nome,
            'tipo_pessoa': tipo_p,
            'url_entidade': self.url_entidade,
            'descricao': self.descricao
        }
Esempio n. 3
0
class Comptes(db.Model):
    id_compte = db.Column(db.String(50), primary_key=True)
    # id_client = db.Column(db.String(50), db.ForeignKey('client.username'))
    type_compte = db.Column(db.Enum(TypeCompte))
    rib = db.Column(db.String(50))
    solde = db.Column(db.Float(20))
    date_creation = db.Column(db.Date)
Esempio n. 4
0
class Monitor(db.Model):
    """Endpoint Monitor.

    Data model of an Endpoint.  This model is not normalized.

    """
    __tablename__ = 'monitors'
    __table_args__ = (
        CheckConstraint('port > 0 AND port < 65536', name='valid_port_range'),
    )
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), nullable=False)
    slug = db.Column(db.String(), index=True, unique=True, nullable=False)
    created = db.Column(db.TIMESTAMP(timezone=True),
                        default=datetime.utcnow, nullable=False)
    updated = db.Column(db.TIMESTAMP(timezone=True),
                        default=datetime.utcnow,
                        onupdate=datetime.utcnow, nullable=False)
    frequency = db.Column(db.Integer, nullable=False)
    scheme = db.Column(db.String(16), nullable=False)
    server = db.Column(db.String(256), nullable=False)
    port = db.Column(db.Integer, nullable=False)
    path = db.Column(db.String)
    verb = db.Column(db.Enum(HTTPVerb))
    payload = db.Column(db.Text)
    headers = db.Column(MutableJson)
    enabled = db.Column(db.Boolean(name='monitor_enabled'), nullable=False)

    def __repr__(self):
        return "<Monitor {}: >".format(self.slug, self.name)
Esempio n. 5
0
class User(PaginatedAPIMixin, UserMixin, dbase.Model):
    id = dbase.Column(dbase.Integer, primary_key=True)
    username = dbase.Column(dbase.String(40), index=True, unique=True)
    nom = dbase.Column(dbase.String(40), index=True, unique=True)
    prenom = dbase.Column(dbase.String(40), index=True, unique=True)
    email = dbase.Column(dbase.String(40), index=True, unique=True)
    password_hash = dbase.Column(dbase.String(120))
    role = dbase.Column(dbase.Enum('admin', 'conseiller', 'client'))
    posts = dbase.relationship('Post', backref='author', lazy='dynamic')

    def __repr__(self):
        return '{}'.format(self.username)

    def to_dict(self, include_email=False):
        data = {
            'id': self.id,
            'username': self.username,
            'post_count': self.posts.count(),
            '_links': {
                'self': url_for('api.get_user', id=self.id)
            }
        }
        if include_email:
            data['email'] = self.email
        return data

    def from_dict(self, data, new_user=False):
        for field in ['username', 'email']:
            if field in data:
                setattr(self, field, data[field])
            if new_user and 'password' in data:
                self.set_password(data['password'])

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        if check_password_hash(self.password_hash, password):
            return True
        else:
            return False

    def get_content(self):
        return self.id, self.username, self.email

    def get_reset_password_token(self, expires_in=60):

        return jwt.encode({'reset_password': self.id, 'exp': time() + expires_in},
                          current_app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')

    @staticmethod
    def verify_reset_password_token(token):

        try:
            id = jwt.decode(token, current_app.config['SECRET_KEY'],
                            algorithms=['HS256'])['reset_password']
        except:
            return
        return User.query.get(id)
Esempio n. 6
0
class Operation(PaginatedAPIMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    done_at = db.Column(db.DateTime, index=True, default=datetime.utcnow)
    valeur = db.Column(db.Float)
    type_operation = db.Column(db.Enum(TypeOp))
    label = db.Column(db.String, default="")
    compte_id = db.Column(db.Integer, db.ForeignKey('compte.id'))
    compte_bis_id = db.Column(db.Integer, db.ForeignKey('compte.id'))

    def __repr__(self):
        return '<Operation {}>'.format(self.id)

    def afficher(self):
        compte = Compte.query.get(self.compte_id)
        compte_dest = Compte.query.get(self.compte_bis_id or -1)
        return {
            'Fait le':
            self.done_at,
            'Valeur':
            self.valeur,
            'Type':
            "dépot" if self.type_operation.name == "depot" else
            self.type_operation.name,
            'Émetteur':
            compte.format_name() if compte_dest else "",
            'Bénéficiaire':
            compte_dest.format_name() if compte_dest else "",
            'Motif':
            self.label or ""
        }

    def to_dict(self):
        data = {
            'id': self.id,
            'done_at': self.done_at,
            'valeur': self.valeur,
            'compte_id': self.compte_id,
            'type_operation': self.type_operation.name,
            'label': self.label
        }
        if self.compte_bis_id:
            data['compte_bis_id'] = self.compte_bis_id
        return data

    def from_dict(self, data):
        for field in [
                'id', 'done_at', 'valeur', 'compte_id', 'type_operation',
                'label'
        ]:
            if field in data:
                setattr(self, field, data[field])
Esempio n. 7
0
class DadosBancarios(db.Model):
    __tablename__ = 'dados_bancarios'

    dados_bancarios_id = db.Column(db.Integer, primary_key=True)
    acao_id = db.Column(db.Integer,
                        db.ForeignKey('acoes.acao_id'),
                        nullable=False)
    banco = db.Column(db.String())
    agencia = db.Column(db.String())
    operacao = db.Column(db.String())
    conta = db.Column(db.String())
    nome_beneficiado = db.Column(db.String())
    tipo_beneficiado = db.Column(db.Enum(TipoBeneficiado), nullable=False)
    id_beneficiado = db.Column(db.String())

    def __init__(self, acao_id, banco, agencia, operacao, conta,
                 nome_beneficiado, tipo_beneficiado, id_beneficiado):
        self.acao_id = acao_id
        self.banco = banco
        self.agencia = agencia
        self.operacao = operacao
        self.conta = conta
        self.nome_beneficiado = nome_beneficiado
        self.tipo_beneficiado = tipo_beneficiado
        self.id_beneficiado = id_beneficiado

    def __repr__(self):
        return '<Localizacao: %r>' % self.acao_id

    def serialize(self):
        tipo_b = None
        if self.tipo_beneficiado:
            tipo_b = self.tipo_beneficiado.value
        return {
            'dados_bancarios_id': self.dados_bancarios_id,
            'acao_id': self.acao_id,
            'banco': self.banco,
            'agencia': self.agencia,
            'operacao': self.operacao,
            'conta': self.conta,
            'nome_beneficiado': self.nome_beneficiado,
            'tipo_beneficiado': tipo_b,
            'id_beneficiado': self.id_beneficiado
        }
Esempio n. 8
0
class Acao(db.Model):
    __tablename__ = 'acoes'

    acao_id = db.Column(db.Integer, primary_key=True)
    entidade_id = db.Column(db.Integer,
                            db.ForeignKey('entidades.entidade_id'),
                            nullable=False)
    nome_acao = db.Column(db.String(), nullable=False)
    imagem_acao = db.Column(db.String())
    url_acao = db.Column(db.String())
    descricao = db.Column(db.String())
    contato = db.Column(db.String())
    tipo_ajuda = db.Column(db.Enum(TipoAjuda), nullable=False)
    forma_ajuda = db.Column(db.Enum(FormaAjuda), nullable=False)
    data_insercao = db.Column(db.DateTime())
    data_atualizacao = db.Column(db.DateTime())
    forma_verificacao = db.Column(db.String())
    resp_verificacao = db.Column(db.String())
    ativa = db.Column(db.Boolean)
    permanente = db.Column(db.Boolean)
    validade = db.Column(db.String())
    entidade = db.relationship(Entidade,
                               foreign_keys=entidade_id,
                               backref='entidade_acao')
    localizacoes = db.relationship(
        Localizacao, primaryjoin="and_(Acao.acao_id==Localizacao.acao_id)")
    midias = db.relationship(NaMidia,
                             primaryjoin="and_(Acao.acao_id==NaMidia.acao_id)")
    dados_bancarios = db.relationship(
        DadosBancarios,
        primaryjoin="and_(Acao.acao_id==DadosBancarios.acao_id)")

    def __init__(self, entidade_id, nome_acao, imagem_acao, url_acao,
                 descricao, contato, tipo_ajuda, forma_ajuda,
                 forma_verificacao, resp_verificacao, ativa, permanente,
                 validade):
        self.entidade_id = entidade_id
        self.nome_acao = nome_acao
        self.imagem_acao = imagem_acao
        self.url_acao = url_acao
        self.descricao = descricao
        self.contato = contato
        self.tipo_ajuda = tipo_ajuda
        self.forma_ajuda = forma_ajuda
        self.data_insercao = datetime.now()
        self.data_atualizacao = datetime.now()
        self.forma_verificacao = forma_verificacao
        self.resp_verificacao = resp_verificacao
        self.ativa = ativa
        self.permanente = permanente
        self.validade = validade

    def __repr__(self):
        return '<Acão %r>' % self.nome_acao

    def serialize(self):
        tipo_a = None
        forma_a = None
        if self.tipo_ajuda:
            tipo_a = self.tipo_ajuda.value
        if self.forma_ajuda:
            forma_a = self.forma_ajuda.value
        return {
            'acao_id':
            self.acao_id,
            'entidade_id':
            self.entidade_id,
            'nome_acao':
            self.nome_acao,
            #'imagem_acao': self.imagem_acao,
            'url_acao':
            self.url_acao,
            'descricao':
            self.descricao,
            'contato':
            self.contato,
            'tipo_ajuda':
            tipo_a,
            'forma_ajuda':
            forma_a,
            'data_insercao':
            self.data_insercao,
            'data_atualizacao':
            self.data_atualizacao,
            'forma_verificacao':
            self.forma_verificacao,
            'resp_verificacao':
            self.resp_verificacao,
            'ativa':
            self.ativa,
            'permanente':
            self.permanente,
            'validade':
            self.validade,
            'nome_entidade':
            self.entidade.nome,
            'localizacoes':
            [localizacao.serialize() for localizacao in self.localizacoes],
            'midias': [midia.serialize() for midia in self.midias],
            'dados_bancarios': [
                dado_bancario.serialize()
                for dado_bancario in self.dados_bancarios
            ]
        }