class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
role_id = db.Column(db.Integer,
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Artist(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
albums = db.relationship('Album', backref='artist', lazy=True)
def __repr__(self):
return f"Artist('{self.name}')"
class TenantModel(db.Model):
#nombre tabla
__tablename__ = 'tenant'
#columns
tenant_id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=True)
last_name = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(100), unique=True, nullable=False)
encrypted_password = db.Column(db.String(100), nullable=False)
rental_unit_id = db.Column(db.Integer, nullable=True)
lease_document_url = db.Column(db.String(100), nullable=True)
id_document_url = db.Column(db.String(100), nullable=True)
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.now)
updated_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.now)
#init data
def __init__(self, first_name, last_name, email, encrypted_password):
#declare data
self.first_name = first_name
self.last_name = last_name
self.email = email
self.encrypted_password = self.create_password(encrypted_password)
#Generate Hash password
def create_password(self, encrypted_password):
return generate_password_hash(encrypted_password)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
cat_name = db.Column(db.String(), unique=True, nullable=False)
dish = db.relationship('Dish', backref='category', lazy=True)
def __repr__(self):
return f"Categeory: '{self.cat_name}'"
class NaMidia(db.Model):
__tablename__ = 'na_midia'
na_midia_id = db.Column(db.Integer, primary_key=True)
acao_id = db.Column(db.Integer,
db.ForeignKey('acoes.acao_id'),
nullable=False)
midia_url = db.Column(db.String())
midia = db.Column(db.String())
def __init__(self, acao_id, midia_url, midia):
self.acao_id = acao_id
self.midia_url = midia_url
self.midia = midia
def __repr__(self):
return '<NaMidia: %r>' % self.midia_url
def serialize(self):
return {
'na_midia_id': self.na_midia_id,
'acao_id': self.acao_id,
'midia_url': self.midia_url,
'midia': self.midia
}
class Base(db.Model):
""" Base model for other database tables to inherit """
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), unique=False, nullable=False)
detail = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self):
return '<Todo %r>' % self.title
class User(db.Model, UserMixin):
"""
User for RRVS
"""
__tablename__="users"
__table_args__ = {'schema':'users'}
id = db.Column(db.Integer(), primary_key=True)
authenticated = db.Column(db.Boolean, default=False)
password = ''
def is_active(self):
"""True, as all users are active."""
return True
def get_id(self):
"""Return the taskid to satisfy Flask-Login's requirements."""
return self.id
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
def is_anonymous(self):
"""False, as anonymous users aren't supported."""
return False
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class author_table(db.Model):
author_id = db.Column(db.Integer, primary_key=True)
author_firstname = db.Column(db.String(255))
author_lastname = db.Column(db.String(255))
def __repr__(self):
return '<Author FirstName: {} \n Author Lastname: {}'.format(self.author_firstname, self.author_lastname)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
_username = db.Column(db.String(32), index=True)
_password_hash = db.Column(db.String(128))
_email = db.Column(db.String(120), index=True, unique=True)
dogs = db.relationship('Dog', back_populates='user')
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id)
except NameError:
return str(self.id)
def __init__(self, username, password_hash, email):
self._username = username
self._password_hash = password_hash
self._email = email
class Save(db.Model):
id = db.Column(db.Integer, primary_key=True)
house_id = db.Column(db.Integer, index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<User {}>'.format(self.username)
class CompteEpargne(Compte):
__tablename__ = 'compte_epargne'
__mapper_args__ = {'polymorphic_identity': 'compte_epargne'}
id = db.Column(db.Integer, db.ForeignKey('compte.id'), primary_key=True)
num_compte = db.Column(db.Integer, index=True, unique=True)
taux_remuneration = db.Column(db.Float, default=0.02)
seuil_remuneration = db.Column(db.Integer, default=1000)
#def __init__(self, data_compte, data_compte_epargne):
# super().__init__(data_compte)
# self.num_compte, self.rib , self.plafond, self.seuil_remuneration = data_compte_epargne
# self.__class__.cnx, self.cursor = None, None
def virement_epargne(self, montant_virement, cnx=None):
pass
def crediter(self,
data_compte,
data_compte_epargne,
somme_versee,
cnx=None):
pass
def remunerer(self, data_compte, data_compte_epargne, cnx=None):
pass
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(120))
password = db.Column(db.String(64))
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
self.password = generate_password_hash(self.password)
# Flask-Login integration
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def is_active(self):
return True
def get_id(self):
return self.id
# Required for administrative interface
def __unicode__(self):
return self.login
def __repr__(self):
return '<User for {0}>'.format(self.login)
class Address(db.Model, SpamsubMixin):
""" Address table """
address = db.Column(db.String(250),
nullable=False,
unique=True,
index=True)
count = db.Column(db.Integer(), default=1)
def __init__(self, address):
self.address = address
@classmethod
def exists(self, address):
""" Check if an address exists, increment counter if it does """
exsts = self.query.filter_by(address=address).first()
if exsts:
exsts.count += 1
db.session.add(exsts)
db.session.commit()
return True
return False
@classmethod
def top(self, number=3):
""" Return top spammers """
return [{
"x": each.address,
"y": each.count
} for each in self.query.order_by(self.count.desc()).limit(
number).all()]
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
pin = db.Column(db.String(4), unique=False, nullable=False)
is_admin = db.Column(db.Boolean(), unique=False, default=False)
date_created = db.Column(db.DateTime,
unique=False,
default=datetime.utcnow)
prediction = db.relationship('Prediction',
cascade="all,delete",
backref='parent')
def __init__(self, username):
self.username = username
self.pin = self.create_pin()
self.is_admin = self.admin_status()
def create_pin(self):
if self.username == 'admin':
return Config.ADMIN_PIN
else:
return ''.join([str(random.randint(0, 9)) for _ in range(4)])
def admin_status(self):
if self.username == 'admin':
return True
else:
False
def __repr__(self):
return f'<User({self.id}, {self.pin}, {self.is_admin})>'
class User(db.Model):
__tablename__ = "users"
id = Column(String(32), primary_key=True, unique=True)
name = Column(String(200), nullable=False, primary_key=True)
email = Column(String(200), nullable=False, primary_key=True)
password_hash = db.Column(db.String(255), nullable=False)
salt = db.Column(db.String(255), nullable=False)
created_at = Column(DateTime)
accesstokens = relationship("AccessToken", back_populates="users")
def __init__(self, name, email, password):
self.created_at = datetime.utcnow()
self.id = str(uuid.uuid4().hex)
self.name = name
self.email = email
self.salt = uuid.uuid4().hex
self.password_hash = User.hash_password(salt=self.salt,
password=password)
def to_json(self):
return {"id": self.id, "name": self.name, "email": self.email}
def check_password(self, password):
current_password = self.hash_password(self.salt, password)
if (current_password == self.password_hash):
return True
else:
return False
@staticmethod
def hash_password(salt, password):
return hashlib.sha512((password + salt).encode('utf-8')).hexdigest()
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 Cancer(db.Model):
id = db.Column(db.Integer, primary_key=True)
cancer_type = db.Column(db.String(100), unique=True, nullable=False)
#cancer_id =
def __repr__(self):
return f"Cancer Type('{self.cancer_type}')"
class APIBackup(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False, default=get_date_time)
backup = db.Column(db.Text, nullable=False)
def __repr__(self):
return f"APIBackup('{self.id}', '{self.date}', '{self.backup}')"
class Author(db.Model):
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.String)
def __init__(self, name):
self.name = name
class SPUser(UserMixin, db.Model):
id = db.Column(db.String(16), primary_key=True)
username = db.Column(db.String(15), unique=True)
firstname = db.Column(db.String(20))
lastname = db.Column(db.String(30))
email = db.Column(db.String(120), unique=True)
role = db.Column(db.String(40), nullable=False)
password_hash = db.Column(db.String(128))
password = db.Column(db.String(60))
active_features = db.Column(db.Text, nullable=False, default="[]")
homepage_order = db.Column(db.Text, nullable=False, default="{}")
# sp_post = db.relationship('SPPost', backref='spuser', lazy=True)
def __repr__(self):
return f"User('{self.id}', '{self.firstname}', '{self.lastname}', '{self.username}', '{self.role}', '{self.email}')"
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
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 BlogImage(db.Model):
blog_id = db.Column(db.String(16), primary_key=True)
image_no = db.Column(db.Integer, primary_key=True)
image = db.Column(db.PickleType)
def __repr__(self):
return f"BlogImage('{self.blog_id}', '{self.image_no}', '{self.image}')"
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String, nullable=False)
text = db.Column(db.Text, nullable=True)
def __repr__(self):
return f'<Comment by {self.author}: {self.text}>'
class User(UserMixin, db.Model):
id = db.Column(db.String(16), primary_key=True)
username = db.Column(db.String(20), unique=True)
firstname = db.Column(db.String(20))
lastname = db.Column(db.String(30))
email = db.Column(db.String(120), unique=True)
role = db.Column(db.String(40), nullable=False)
password_hash = db.Column(db.String(128))
password = db.Column(db.String(60))
active_features = db.Column(db.PickleType, default=[])
homepage_order = db.Column(db.PickleType, default={})
post = db.relationship('BlogPost', backref='user', lazy=True)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
def __repr__(self):
return f"User('{self.id}', '{self.firstname}', '{self.lastname}', '{self.username}', '{self.role}', '{self.email}')"
def update(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
class TenantLeaseModel(db.Model):
#nombre tabla
__tablename__ = 'tenant_lease'
#columns
tenant_lease_id = db.Column(db.Integer, primary_key=True)
lease_id = db.Column(db.Integer,
db.ForeignKey('tenant.tenant_id'),
primary_key=True)
tenant_id = db.Column(db.Integer,
db.ForeignKey('lease.lease_id'),
primary_key=True)
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.now)
updated_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.now)
#init data
def __init__(self, lease_id, tenant_id):
#declare data
self.lease_id = lease_id
self.tenant_id = tenant_id
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True, index=True, nullable=False)
username = db.Column(db.String(40), index=True, nullable=False)
feature = db.Column(db.String(200), nullable=True)
def __repr__(self):
return '<User %r>' % (self.username)
class Subject(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(30), nullable=False)
def __repr__(self):
return f"Subject('{self.name}')"
class User(db.Model):
vkid = db.Column(db.String, primary_key=True)
steamid = db.Column(db.String, index=True, unique=True)
score = db.Column(db.Integer)
def __repr__(self):
return self.vkid
