class Transaction(db.Model):
"""
Class for Transactions table
"""
__tablename__ = 'transactions'
id = db.Column(db.Integer, primary_key=True)
amount = db.Column(db.Numeric(), nullable=False)
paid_on = db.Column(db.DateTime)
payment_status = db.Column(db.Enum(PaymentStatus))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
expense_id = db.Column(db.Integer,
db.ForeignKey('expenses.id'),
nullable=False)
updated_at = db.Column(db.DateTime)
user = db.relationship('User', back_populates='transaction')
expense = db.relationship('Expense', back_populates='transaction')
def __init__(self, expense_id, user_id, amount):
self.amount = Decimal(amount)
self.user_id = user_id
self.expense_id = expense_id
self.payment_status = PaymentStatus.PENDING
self.update_at = datetime.datetime.now()
def __repr__(self):
return f'<Transaction {self.id}>'
class User(UserMixin, db.Model):
__tablename__="users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String (200), nullable=False)
mobile = db.Column(db.String, nullable=False, unique=True)
email = db.Column(db.String (200), index = True, unique=True)
password_hash = db.Column(db.String(1200))
tokens = db.relationship("Token", backref="user", lazy=True)
order = db.relationship("Order", backref="user", lazy=True)
location = db.relationship("Location", backref="user", lazy=True)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def check_user(self):
return User.query.filter_by(email=self.email).first()
def add(self):
db.session.add(self)
db.session.commit()
def get_json(self):
return {
"id": self.id,
"username": self.username,
"mobile": self.mobile,
"email": self.email
}
class Ratings(db.Model): # rating or like???
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
event_id = db.Column(db.Integer, db.ForeignKey('event.id'), nullable=False)
stars = db.Column(db.Integer, nullable=False)
user = db.relationship('User', backref='user', lazy=True)
event = db.relationship('Event', backref='event', lazy=True)
class Tweet(SearchableMixin, db.Model):
__searchable__ = ['textbody']
id = db.Column(db.Integer, primary_key=True)
identifier = db.Column(db.String(32), nullable=False)
textbody_source = db.Column(db.String(500), nullable=False)
textbody_markdown = db.Column(db.Text(), nullable=False)
userid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='tweet', lazy="dynamic")
created_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
edited_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
stickied = db.Column(db.Boolean, default=False)
is_banned = db.Column(db.Boolean, default=False)
is_nsfw = db.Column(db.Boolean, default=False)
is_edited = db.Column(db.Boolean, default=False)
comment_path_counter = db.Column(db.Integer, default=1, autoincrement=True)
likes = db.relationship('Like', backref='tweet', lazy='dynamic')
@classmethod
def get_identifier(cls):
while True:
ident = secrets.token_hex(nbytes=16)
if not cls.query.filter_by(identifier=ident).first():
return ident
def __repr__(self):
return '<Tweet {}>'.format(self.id)
class Role(db.Model):
"""Hold Role Details."""
__tablename__ = 'sec_roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(50), nullable=False, unique=True)
role_description = db.Column(db.String(255), nullable=False)
users = db.relationship('User', secondary='sec_users_roles',
backref=db.backref('users', lazy='dynamic'))
menus = db.relationship('navigation.models.Menu',
secondary='nav_roles_menus',
backref=db.backref('roles', lazy='dynamic'))
is_active = db.Column(db.Boolean(), nullable=False, server_default='1')
created_by = db.Column(db.Integer)
created_datetime = db.Column(db.DateTime, default=datetime.now())
modified_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
is_default = db.Column(db.Boolean(), default=False)
def __init__(self, role_name, role_description, created_by):
"""Create a new role."""
self.role_name = role_name
self.role_description = role_description
self.created_by = created_by
self.created_datetime = datetime.now()
def __repr__(self):
"""Represent an instance of the class."""
return self.role_name
class Prize(db.Model):
id = db.Column(db.Integer, primary_key=True)
challenge_id = db.Column(db.Integer,
db.ForeignKey('challenge.id'),
index=True,
nullable=False)
challenge = db.relationship('Challenge', backref='prizes')
sponsor_id = db.Column(db.Integer,
db.ForeignKey('sponsor.id'),
index=True,
nullable=False)
sponsor = db.relationship('Sponsor', backref='prizes')
name = db.Column(db.String(240), nullable=False)
count = db.Column(db.Integer, default=1)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, challenge, sponsor, name, count):
self.challenge = challenge
self.sponsor = sponsor
self.name = name
self.count = count
def __repr__(self):
return '<Prize id={}, challenge_id={}, sponsor_id={}, count={} is_destroyed={}, created_at={}>'.format(
self.id, self.challenge_id, self.sponsor_id, self.count,
self.is_destroyed, self.created_at)
class Winner(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='winners')
prize_id = db.Column(db.Integer,
db.ForeignKey('prize.id'),
index=True,
nullable=False)
prize = db.relationship('Prize', backref='winners')
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, user=None, prize=None, prize_id=None):
if prize_id:
self.prize_id = prize_id
else:
self.prize = prize
self.user = user
def __repr__(self):
return '<Winner id={}, user_id={}, prize_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.user_id, self.prize_id, self.is_destroyed,
self.created_at)
class Sala(Base):
__tablename__ = 'sala'
# Chave
id = db.Column(db.Integer, primary_key=True, nullable=False)
# Atributos
numero = db.Column(db.String(40), nullable=False)
setor = db.Column(db.String(40), nullable=False)
ramal = db.Column(db.String(40), nullable=False)
# Relações
fichas = db.relationship('Ficha', back_populates='sala')
equipamentos = db.relationship('Contem', back_populates='sala')
consultorio = db.relationship('Consultorio', back_populates='salas')
consultorio_id = db.Column(db.Integer, db.ForeignKey('consultorio.id'))
def __init__(self, numero, setor, ramal, consultorio_id):
self.numero = numero
self.setor = setor
self.ramal = ramal
self.consultorio_id = consultorio_id
def __repr__(self):
return ("[Sala] ID: " + self.id + "\n\t-numero: " + self.numero +
"\n\t-setor: " + self.setor + "\n\t-ramal: " + self.ramal)
class Ficha(Base):
__tablename__ = 'ficha'
# Chave
id = db.Column(db.Integer, primary_key=True)
paciente_cpf = db.Column(db.String(len_cpf), db.ForeignKey('paciente.cpf'))
medico_cpf = db.Column(db.String(len_cpf), db.ForeignKey('medico.cpf'))
sala_id = db.Column(db.Integer, db.ForeignKey('sala.id'))
# Atributos
comentarios = db.Column(db.String(500))
sintomas = db.Column(db.String(500))
exames = db.Column(db.String(500))
# Relações
paciente = db.relationship('Paciente', back_populates='fichas')
medico = db.relationship('Medico', back_populates='fichas')
sala = db.relationship('Sala', back_populates='fichas')
def __init__(self, paciente_cpf, medico_cpf, sala_id):
self.paciente_cpf = paciente_cpf
self.medico_cpf = medico_cpf
self.sala_id = sala_id
def __repr__(self):
return ("[Ficha] ID: " + self.id + "\n\t-paciente_cpf: " +
self.paciente_cpf + "\n\t-medico_cpf: " + self.medico_cpf +
"\n\t-sala_id: " + self.sala_id + "\n\t-comentarios: " +
self.comentarios + "\n\t-sintomas: " + self.sintomas +
"\n\t-exames: " + self.exames)
class Group(db.Model, ResourceMixin):
__tablename__ = 'groups'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, index=True, nullable=False)
description = db.Column(db.String(250))
# relationships
members = db.relationship('User',
secondary=grp_members,
backref=db.backref('groups', lazy='dynamic'),
lazy='dynamic')
permissions = db.relationship('Permission',
secondary=grp_perms,
backref=db.backref('groups', lazy='dynamic'),
lazy='dynamic')
def __init__(self, **kwargs):
super(Group, self).__init__(**kwargs)
self.name = kwargs.get('name').lower()
self.description = kwargs.get('description', '')
def __repr__(self):
return f'<Group: {self.name}>'
@classmethod
def find_by_name(cls, name):
return cls.query.filter((cls.name == name)).first()
def is_group_member(self, user):
return self.members.filter(
grp_members.c.user_id == user.id).count() > 0
def add_members(self, members):
for member in members:
if not self.is_group_member(member):
self.members.append(member)
self.save()
def remove_members(self, members):
for member in members:
if self.is_group_member(member):
self.members.remove(member)
self.save()
def has_perm(self, perm):
return self.permissions.filter(
grp_perms.c.perm_id == perm.id).count() > 0
def add_permissions(self, perms):
for perm in perms:
if not self.has_perm(perm):
self.permissions.append(perm)
self.save()
def remove_permissions(self, perms):
for perm in perms:
if self.has_perm(perm):
self.permissions.remove(perm)
self.save()
class Events(db.Model):
#Location
__tablename__ = 'event'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(132), nullable=False)
description = db.Column(db.Text, nullable=False)
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
organizer_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
ticket_types = db.relationship('TicketTypes', backref='event', lazy=True)
categories = db.relationship('Category',
secondary=event_category,
lazy='subquery',
backref=db.backref('of_events', lazy=True))
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
def __init__(self, name, description):
self.name = name
self.description = description
class User(db.Model):
__tablename__ = 'users'
# __table_args__ = (
# db.ForeignKeyConstraint(
# ["person_id"],
# ["person.id"],
# ),
# )
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, db.ForeignKey('person.id'), nullable=False)
username = db.Column(db.String(40), nullable=False, unique=True, index=True)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean())
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
userProfileSystem = db.relationship("UserProfileSystem", back_populates="users")
person = db.relationship("Person", back_populates="users")
def __init__(self, username, password, is_admin, person_id):
bcrypt = Bcrypt(current_app)
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.is_admin = is_admin
self.person_id = person_id
def compare_password(self, password):
bcrypt = Bcrypt(current_app)
return bcrypt.check_password_hash(self.password, password)
def __repr__(self):
return f'<User: {self.username}'
class Comment(db.Model, ResourceMixin):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE', onupdate='CASCADE'))
post_id = db.Column(
db.Integer,
db.ForeignKey('posts.id', ondelete='CASCADE', onupdate='CASCADE'))
comment_id = db.Column(db.Integer,
db.ForeignKey('comments.id', ondelete='SET NULL'))
replies = db.relationship('Comment', lazy='joined')
likes = db.relationship('User',
secondary=comment_likes,
lazy='dynamic',
backref=db.backref('comment_likes',
lazy='dynamic'))
def __repr__(self):
return f'<Post {self.body}>'
def is_liked_by(self, user):
return self.likes.filter(
comment_likes.c.user_id == user.id).count() > 0
class ItemAddOn(BaseMixin, db.Model, ReprMixin):
item_id = db.Column(UUID, db.ForeignKey('item.id'), index=True)
add_on_id = db.Column(UUID, db.ForeignKey('add_on.id'), index=True)
add_on = db.relationship('AddOn', foreign_keys=[add_on_id])
item = db.relationship('Item', back_populates='add_ons', foreign_keys=[item_id])
class User(BaseMixin, db.Model, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
username = db.Column(db.String(127), nullable=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission')
user_profile = db.relationship("UserProfile",
uselist=False,
back_populates="user",
cascade='all, delete-orphan',
lazy='subquery')
def has_permission(self, permission):
if isinstance(permission, str):
return permission in (permission.name
for permission in self.permissions)
else:
return permission in self.permissions
class Image(db.Model):
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String, unique=True)
restaurants = db.relationship('Restaurant', backref='img', lazy=True)
dishs = db.relationship('Dish', backref='img', lazy=True)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
user_email = db.Column(db.String(64), unique=True, index=True)
user_username = db.Column(db.String(64), unique=True, index=True)
user_posts = db.relationship('Topic', cascade="all, delete-orphan", backref='author', lazy='dynamic')
user_role = db.Column(db.String(10), index=True, default='User')
user_first_name = db.Column(db.String(64), index=True, nullable=True)
user_last_name = db.Column(db.String(64), index=True, nullable=True)
user_birthday = db.Column(db.DateTime(), index=True, nullable=True)
user_date = db.Column(db.DateTime(), index=True, nullable=True)
user_location = db.Column(db.String(64), index=True, nullable=True)
user_about = db.Column(db.String(140), index=True, nullable=True)
user_occupation = db.Column(db.String(100), index=True, nullable=True)
user_interests = db.Column(db.String(100), index=True, nullable=True)
password_hash = db.Column(db.String(128))
user_reply = db.relationship('Reply', cascade="all, delete-orphan", backref='reply_from', lazy='dynamic')
def __init__(self, user_email, user_username, user_password, user_role,
user_date):
self.user_email = user_email
self.user_username = user_username
self.user_role = user_role
self.password_hash = generate_password_hash(user_password)
self.user_date = user_date
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class System(db.Model):
__tablename__ = 'system'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(50), index=True, nullable=False, unique=True)
description = db.Column(db.String(200))
url = db.Column(db.String(200), index=True)
creation_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
systemPermission = db.relationship("SystemPermission",
back_populates="system")
profileSystem = db.relationship("ProfileSystem", back_populates="system")
userProfileSystem = db.relationship("UserProfileSystem",
back_populates="system")
def __init__(self, data):
self.name = data.get('name')
self.description = data.get('description')
self.url = data.get('url')
def __repr__(self):
return f'<System: {self.name}'
class CheckInAnswer(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_in_question_id = db.Column(db.Integer,
db.ForeignKey('check_in_question.id'),
index=True,
nullable=False)
check_in_question = db.relationship('CheckInQuestion',
backref='check_in_answers')
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='check_in_answers')
text = db.Column(db.Text(), nullable=False)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
user,
text,
check_in_question=None,
check_in_question_id=None):
if check_in_question_id:
self.check_in_question_id = check_in_question_id
else:
self.check_in_question = check_in_question
self.user = user
self.text = text
def __repr__(self):
return '<CheckInAnswer id={}, check_in_question_id={}, user_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.check_in_question_id, self.user_id,
self.is_destroyed, self.created_at)
class Customer(db.Model):
__tablename__ = 'customers'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
phone_number = db.Column(db.String, unique=True, nullable=False)
quotes = db.relationship('Quote', backref='customers', lazy=True)
transactions = db.relationship('Transaction',
backref='customers',
lazy=True)
def __init__(self,
id=None,
first_name=None,
last_name=None,
email=None,
phone_number=None):
self.id = id
self.first_name = first_name
self.last_name = last_name
self.email = email
self.phone_number = phone_number
class Cart(db.Model):
id = db.Column(UUIDType(binary=False),
primary_key=True,
default=generate_uuid)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
customer_id = db.Column(UUIDType(binary=False),
db.ForeignKey('user.id'),
nullable=False)
cart_items = db.relationship('CartItem',
backref='cart',
lazy=True,
cascade="delete")
order = db.relationship('Order', backref='cart', lazy=True)
def __repr__(self):
return f"Cart('{self.date_created}', '{self.id}')"
def serialize(self):
return {
"id": self.id,
"customer_id": self.customer_id,
"date_created": self.date_created,
"cart_item_ids": [item.id for item in self.cart_items],
"is_ordered": True if self.order else False
}
class Quote(db.Model):
__tablename__ = 'quotes'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False)
description = db.Column(db.String, nullable=False)
total = db.Column(db.Integer, nullable=False)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.id'),
nullable=False)
quote_items = db.relationship('QuoteItem', backref='quotes', lazy=True)
transactions = db.relationship('Transaction', backref='quotes', lazy=True)
def __init__(self,
id=None,
date=None,
description=None,
total=None,
customer_id=None):
self.id = id
self.date = date
self.description = description
self.total = total
self.customer_id = customer_id
class Usuario(db.Model):
__bind_key__ = 'banco_principal'
__tablename__ = 'usuarios'
id_usuario = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.LargeBinary(length=None), nullable=False)
email = db.Column(db.LargeBinary(length=None), nullable=False)
password = db.Column(db.LargeBinary(length=None), nullable=False)
data_nascimento = db.Column(db.LargeBinary(length=None), nullable=False)
cpf = db.Column(db.LargeBinary(length=None), nullable=False)
funcionario = db.Column(db.LargeBinary(length=None), nullable=False)
agendamentos = db.relationship('Agendamento', backref='usuario')
endereco = db.relationship('Endereco', backref='usuario')
telefones = db.relationship('Telefone', backref=db.backref('usuario', lazy=True))
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return True
def get_id(self):
return f'{self.id_usuario}'
def __repr__(self):
return f'<Usuario {self.id_usuario}>'
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(100), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
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 User(db.Model, BaseMixin, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
name = db.Column(db.String(127), nullable=True)
mobile_number = db.Column(db.String(20), unique=True, nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role', back_populates='users', secondary='user_role')
retail_shops = db.relationship('RetailShop', back_populates='users', secondary='user_retail_shop', lazy='dynamic')
@hybrid_property
def name(self):
return '{0}'.format(self.user_profile.first_name) + (' {0}'.format(self.user_profile.last_name)) \
if self.user_profile.first_name else ''
@hybrid_property
def retail_shop_ids(self):
return [i[0] for i in self.retail_shops.with_entities(RetailShop.id).all()]
@hybrid_property
def brand_ids(self):
return set([i[0] for i in self.retail_shops.with_entities(RetailShop.retail_brand_id).all()])
class Friendship(db.Model):
"""
Class for friendship table between users
params:
- status - ['accepted', 'rejected', 'pending']
"""
__tablename__ = 'friendships'
id = db.Column(db.Integer, primary_key=True)
friend1_id = db.Column(db.Integer, db.ForeignKey(
'users.id'), nullable=False)
friend2_id = db.Column(
db.Integer, db.ForeignKey('users.id'), nullable=False)
status = db.Column(db.String, nullable=False)
updated_at = db.Column(db.DateTime)
friend1 = db.relationship('User', backref='friendship1',
uselist=False, foreign_keys='[Friendship.friend1_id]')
friend2 = db.relationship('User', backref='friendship2',
uselist=False, foreign_keys='[Friendship.friend2_id]')
def __init__(self, friend1_id, friend2_id):
self.friend1_id = friend1_id
self.friend2_id = friend2_id
self.status = 'pending'
self.updated_at = datetime.datetime.now()
class Location(db.Model):
id = db.Column(db.Integer, primary_key=True)
address = db.Column(db.String, nullable=False, index=True)
lat = db.Column(db.Float, nullable=False)
lng = db.Column(db.Float, nullable=False)
campaigns = db.relationship('Campaign', backref='location', lazy=True)
teams = db.relationship('Team', backref='location', lazy=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(120), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
path_to_img = db.Column(db.String(255), unique=True, nullable=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
first_name = db.Column(db.String(100), unique=False, nullable=True)
last_name = db.Column(db.String(100), unique=False, nullable=True)
registration_date = db.Column(db.DATE, unique=False, nullable=False)
roles = db.relationship('Role',
secondary=user_role,
lazy=False,
backref=db.backref('users', lazy=True))
result = db.relationship('Result', backref='user', lazy=True)
courses = db.relationship('Course',
secondary=user_course,
lazy=False,
backref=db.backref('courses', lazy=True))
created_courses = db.relationship('Course',
secondary=user_create_course,
lazy=False,
backref=db.backref('created_courses',
lazy=True))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
image = db.Column(db.String(20), nullable=False, default='default.png')
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
def get_reset_token(self, expire_seconds=1800):
s = Serializer(app.config['SECRET_KEY'], expire_seconds)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except Exception:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image}')"
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
gender = db.Column(db.String)
first_name = db.Column(db.String(80))
last_name = db.Column(db.String(80))
address = db.Column(db.String)
email = db.Column(db.String(120), index=True, unique=True)
user_name = db.Column(db.String(80), nullable=False)
password_hash = db.Column(db.String, nullable=False)
dob = db.Column(db.DateTime)
img_large = db.Column(db.String)
img_medium = db.Column(db.String)
img_thumbnail = db.Column(db.String)
created_date = db.Column(
db.DateTime, nullable=False, default=datetime.utcnow)
updated_date = db.Column(
db.DateTime, nullable=False, default=datetime.utcnow)
isSaler = db.Column(db.Boolean, default=False)
isAdmin = db.Column(db.Boolean, default=False)
isActive = db.Column(db.Boolean, default=True)
products = db.relationship("Product", backref="user", lazy="dynamic")
purchases = db.relationship("Purchase", backref="user", lazy="dynamic")
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __init__(self, **kwargs):
super().__init__(**kwargs)
def __repr__(self):
return f"{self.id} user_name is {self.user_name}."
