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
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
}
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)
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)
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)
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])
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
}
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
]
}