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}."