class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String, nullable=False, unique=True) email = db.Column(db.String, nullable=False, unique=True) phone = db.Column(db.String) password = db.Column(db.String, nullable=False) def __init__(self, username, email, phone=None, password=None): self.username = username self.email = email self.phone = phone self.password = password def __repr__(self): return u'<User %s>' % self.username def set_password(self, password): self.password = bcrypt.generate_password_hash(password) def check_password(self, password): return bcrypt.check_password_hash(self.password, password) def get_auth_token(self): data = [str(self.id), (self.username, self.password)] return login_serializer.dumps(data)
class EventPromoter(db.Model): class Role(IntEnum): COPROMOTER = auto() MAIN = auto() class Status(IntEnum): PENDING = auto() APPROVED = auto() REJECTED = auto() event_id = db.Column(db.Integer, db.ForeignKey('event.id'), primary_key=True) promoter_id = db.Column(db.Integer, db.ForeignKey('promoter.id'), primary_key=True) role = db.Column(db.Integer, default=Role.MAIN.value, nullable=False) status = db.Column(db.Integer, default=Status.PENDING.value, nullable=False) event = db.relationship('Event', backref=db.backref('event_promoters')) promoter = db.relationship('Promoter', backref=db.backref('event_promoters', lazy='dynamic'))
class Breed(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) def __init__(self, name): self.name = name def __repr__(self): return u'<Breed %s>' % self.name
class Parecer(db.Model): __tablename__ = 'parecer' id = db.Column(db.Integer, primary_key=True) fiscalCampo = db.Column(db.String(50)) bilhete_id = db.Column(db.Integer, db.ForeignKey('bilhete.id')) def __init__(self, fiscalCampo=None, bilhete_id=None): self.fiscalCampo = fiscalCampo self.bilhete_id = bilhete_id
class Dog(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) description = db.Column(db.String) breed_id = db.Column(db.Integer, db.ForeignKey('breed.id')) breed = db.relationship(Breed, backref='dogs') user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship(User, backref='dogs') photo = db.Column(db.Unicode) size = db.Column(db.String) born_date = db.Column(db.Date) location = db.Column(db.String) def __init__(self, name, description=None, size=None, photo=None, born_date=None, breed_id=None, location=None, user_id=None): self.name = name self.description = description self.size = size self.photo = photo self.born_date = born_date self.breed_id = breed_id self.location = location self.user_id = user_id def __repr__(self): return u'<Dog %s>' % self.name
class Promoter(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(30), nullable=False, unique=True, index=True) name = db.Column(db.String(100), nullable=False, index=True) description = db.Column(db.String) created_on = db.Column(db.DateTime, nullable=False, default=datetime.now) longitude = db.Column(db.Float(precision=9)) latitude = db.Column(db.Float(precision=9)) email = db.Column(db.String(40)) category_id = db.Column(db.Integer, db.ForeignKey('event_category.id')) category = db.relationship(EventCategory) users = db.relationship('User', secondary='promoter_user', backref=db.backref('promoters')) def __repr__(self): return f'<Promoter: {self.username}>' def get_user_role(self, user: User): promoter_user = PromoterUser.query.filter( PromoterUser.user == user).first() return promoter_user.role
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(128), nullable=False) email = db.Column(db.String(128), nullable=False) active = db.Column(db.Boolean(), default=True, nullable=False) def __init__(self, username, email): self.username = username self.email = email
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String, nullable=False) text = db.Column(db.String, nullable=False) def __init__(self, title, text): self.title = title self.text = text def __repr__(self): return f'<title {self.title}>'
class EventCategory(db.Model): __tablename__ = 'event_category' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False, unique=True, index=True) description = db.Column(db.String) default = db.Column(db.Boolean, default=False) parent_id = db.Column(db.Integer, db.ForeignKey('event_category.id'), nullable=True) children = db.relationship('EventCategory') def __repr__(self): return f'<Event category: {self.name}'
class Bilhete(db.Model): __tablename__ = 'bilhete' id = db.Column(db.Integer, primary_key=True) num_bilhete = db.Column(db.String(10)) date_posted = db.Column(db.DateTime, nullable=False) parecer = db.relationship('Parecer', uselist=False, backref='bilhete', lazy='dynamic') def __init__(self, num_bilhete=None, date_posted=None): self.num_bilhete = num_bilhete self.date_posted = datetime.datetime.now()
class Accountdetails(db.Model): __tablename__ = "accountdetails" id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) company = db.Column(db.String(128), nullable=False) job_title = db.Column(db.String(100), nullable=False) city = db.Column(db.String(100), nullable=False) country = db.Column(db.String(100), nullable=False) instituition = db.Column(db.String(100), nullable=False) about_me = db.Column(db.String(140), nullable=False) def __init__(self, **kwargs): super(Accountdetails, self).__init__(**kwargs) def to_json(self): return { 'id': self.id, 'user_id': self.user_id, 'company': self.company, 'job_title': self.job_title, 'city': self.city, 'country': self.country, 'instituition': self.instituition, 'about_me': self.about_me }
class COURSE(db.Model): __tablename__ = "course_users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) firstname = db.Column(db.String(128), nullable=True) lastname = db.Column(db.String(128), nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) password = db.Column(db.String, nullable=False) admin = db.Column(db.Boolean, default=False, nullable=False) email_sent = db.Column(db.Boolean, default=False, nullable=False) confirmed = db.Column(db.Boolean, default=False, nullable=False) def __init__(self, firstname, lastname, email, password): self.firstname = firstname self.lastname = lastname self.email = email self.password = bcrypt.generate_password_hash(password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode() def to_json(self): return { 'id': self.id, 'firstname': self.firstname, 'lastname': self.lastname, 'email': self.email, 'admin': self.admin, 'email_sent': self.email_sent, 'confirmed': self.confirmed } def encode_auth_token(self, user_id): try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta( days=current_app.config.get('TOKEN_EXPIRATION_DAYS'), seconds=current_app.config.get('TOKEN_EXPIRATION_SECONDS') ), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode( payload, current_app.config.get('SECRET_KEY'), algorithm='HS256' ) except Exception as e: return e @staticmethod def decode_auth_token(auth_token): try: payload = jwt.decode(auth_token, current_app.config.get('SECRET_KEY')) return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again' except jwt.InvalidTokenError: return 'Invalid Token. Please log in again'
class EventUpdate(db.Model): class Tag(IntEnum): GENERAL = auto() TICKETS = auto() DATES = auto() LINE_UP = auto() MERCH = auto() LOCATION = auto() id = db.Column(db.Integer, primary_key=True) event_id = db.Column(db.Integer, db.ForeignKey('event.id')) datetime = db.Column(db.DateTime, nullable=False, default=datetime.now) tag = db.Column(db.Integer, nullable=False, default=Tag.GENERAL.value) text = db.Column(db.Text)
class NewCourse(db.Model): __tablename__ = "newcourse" id = db.Column(db.Integer, primary_key=True, autoincrement=True) coursetitle = db.Column(db.String(128), nullable=False) coursedetails = db.Column(db.String(300), nullable=False) def __init__(self, **kwargs): super(NewCourse, self).__init__(**kwargs) def to_json(self): return { 'id': self.id, 'coursetitle': self.coursetitle, 'coursedetails': self.coursedetails, }
class PromoterUser(db.Model): class Role(IntEnum): SUPPORT = auto() CREATOR = auto() ADMIN = auto() promoter_id = db.Column(db.Integer, db.ForeignKey('promoter.id'), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) role = db.Column(db.Integer, default=Role.SUPPORT.value, nullable=False) promoter = db.relationship('Promoter', backref=db.backref('roles')) user = db.relationship('User', backref=db.backref('roles')) @classmethod def get_minimum_role_for_event(cls): return cls.Role.CREATOR
class ProfileImage(db.Model): __tablename__ = "profileimage" id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) image_location = db.Column(db.String(128), nullable=False) border_radius = db.Column(db.String(100), nullable=False) status = db.Column(db.String(140), nullable=False) def __init__(self, **kwargs): super(ProfileImage, self).__init__(**kwargs) def to_json(self): return { 'id': self.id, 'user_id': self.user_id, 'image_location': self.image_location, 'border_radius': self.border_radius, 'status': self.status, }
class Replay(db.Model): __tablename__ = 'replay' id = db.Column(db.Integer, primary_key=True, autoincrement=True) guid = db.Column(db.String(128), default=False, nullable=False) version = db.Column(db.Integer, default=False, nullable=False) release = db.Column(db.String(128), default=False, nullable=False) created_at = db.Column(db.DateTime, nullable=False, server_default=func.now()) total_players = db.Column(db.Integer, default=False, nullable=False) elimination_events = db.relationship("Elimination", backref="Replay") stats = db.relationship("ReplayStats", backref="Replay") @hybrid_property def weapon_usage(self): return Counter(i.weapon_type for i in self.elimination_events) def __init__(self, **kwargs): super(Replay, self).__init__(**kwargs) def __json__(self): return ['id', 'guid', 'created_at', 'total_players', 'weapon_usage']
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) password_hash = db.Column(db.String) pomodoros = db.relationship('Pomodoro', backref='user', lazy='dynamic') @property def password(self, password): raise AttributeError('password: write-only field') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) @staticmethod def get_by_username(username): return User.query.filter_by(username=username).first() def __repr__(self): return "<User {}>".format(self.username)
class Elimination(db.Model): __tablename__ = 'elimination' id = db.Column(db.Integer, primary_key=True, autoincrement=True) replay_id = db.Column(db.Integer, db.ForeignKey('replay.id', ondelete='CASCADE')) eliminator = db.Column(db.String(255), nullable=False) eliminated = db.Column(db.String(255), nullable=False) knocked = db.Column(db.Boolean) weapon_type = db.Column(db.Integer, default=False, nullable=False) time = db.Column(db.DateTime, default=False, nullable=False) def __init__(self, replayId, **kwargs): super(Elimination, self).__init__(**kwargs) def __json__(self): return ['eliminator', 'eliminated', 'knocked', 'weapon_type', 'time']
class Pomodoro(db.Model): id = db.Column(db.Integer, primary_key=True) length_seconds = db.Column(db.Integer, default=1500) # Default 25 minutes end_time = db.Column(db.DateTime, default=datetime.utcnow) context = db.Column(db.String(80), default="") interruptions = db.Column(db.Integer) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) @staticmethod def create_new_pomodoro(context, interruptions, user_id): pomodoro = Pomodoro(context=context, interruptions=interruptions, user_id=user_id) db.session.add(pomodoro) db.session.commit() @staticmethod def past_n_days(n, user_id): now = datetime.utcnow() n_days_ago = now - timedelta(days=n) # TODO: floor to midnight res = db.session.query(Pomodoro).filter( Pomodoro.user_id == user_id, Pomodoro.end_time > n_days_ago, Pomodoro.end_time <= now).all() return res
class Event(db.Model): minumum_duration = relativedelta(minutes=30) id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) longitude = db.Column(db.Float(precision=9)) latitude = db.Column(db.Float(precision=9)) datetime_from = db.Column(db.DateTime, nullable=False, default=datetime.now) datetime_to = db.Column(db.DateTime) capacity = db.Column(db.Integer, default=0) profit = db.Column(db.Boolean, default=False, nullable=False) subcateogries = db.relationship('EventCategory', secondary=event_subcategories) main_category_id = db.Column(db.Integer, db.ForeignKey('event_category.id')) main_category = db.relationship('EventCategory') updates = db.relationship('EventUpdate', backref='event') def __repr__(self): return f'Event: {self.name}' @classmethod def create_event(cls, user: User, main_promoters: list, copromoters: list = [], **kwargs): event = cls(**kwargs) db.session.add(event) db.session.commit() for promoter in main_promoters: event.assign_promoter(promoter=promoter, user=user, main=True) for promoter in copromoters: event.assign_promoter(promoter, user) return event def assign_promoter(self, promoter: Promoter, user: User, main: bool = False): event_promoter = EventPromoter(event=self, promoter=promoter, role=EventPromoter.Role.MAIN.value) user_role = promoter.get_user_role(user) if user_role >= PromoterUser.Role.CREATOR.value: event_promoter.status = EventPromoter.Status.APPROVED db.session.add(event_promoter) db.session.commit() def create_update(self, text: str, tag: int = None, **kwargs): event_update = EventUpdate(tag=tag, text=text) self.updates.append(event_update) db.session.commit() return event_update
from datetime import datetime from enum import IntEnum, auto from dateutil.relativedelta import relativedelta from project.app import db from project.apps.promoter.models.promoter import Promoter, PromoterUser from project.apps.user.models.user import User from .eventCategory import EventCategory from .eventUpdate import EventUpdate event_subcategories = db.Table( 'event_subcategories', db.Column('event_id', db.Integer, db.ForeignKey('event.id'), primary_key=True), db.Column('category_id', db.Integer, db.ForeignKey('event_category.id'), primary_key=True)) class Event(db.Model): minumum_duration = relativedelta(minutes=30) id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) longitude = db.Column(db.Float(precision=9)) latitude = db.Column(db.Float(precision=9)) datetime_from = db.Column(db.DateTime,
class MembershipPlan(db.Model): __tablename__ = 'membership_plan' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100)) description = db.Column(db.String(1000)) price = db.Column(db.Numeric) project_limit = db.Column(db.Integer) user_limit = db.Column(db.Integer) plan_duration = db.Column(db.Text) created_at = db.Column(db.TIMESTAMP) created_by = db.Column(db.String(50)) updated_at = db.Column(db.Date) updated_by = db.Column(db.String(50)) is_active = db.Column(db.Boolean, default = True) is_deleted = db.Column(db.Boolean, default = False) def __init__(self, id = None, name = "", description = "", price = None, project_limit = None, user_limit = None, plan_duration = None, created_by = "", created_at = "", is_active = "", is_deleted = ""): self.id = id self.name = name self.description = description self.price = price self.project_limit = project_limit self.user_limit = user_limit self.plan_duration = plan_duration self.created_at = datetime.now() self.created_by = created_by @classmethod def get(cls, id: int): return MembershipPlan.query.get(id) @classmethod def all(cls): return cls.query.filter_by(is_deleted = False, is_active = True).order_by(cls.created_at.desc()) def to_json(self): return json.loads(json.dumps({ "id": self.id, "name" : self.name, "description":self.description, "price":self.price, "project_limit" : self.project_limit, "user_limit" : self.user_limit, "plan_duration" : self.plan_duration, "created_by" : self.created_by, "created_at" : self.created_at, "updated_at" : self.updated_at, "updated_by" : self.updated_by, "is_active" : self.is_active }, default=default_proc)) def save(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() def exists(self, id): return db.session.query(db.exists().where(id == id)).scalar() def delete(self): if self.is_deleted: return Response.createFailResponse(self, ResponseMessages.not_found, HTTPStatus.NO_CONTENT) self.is_deleted = True db.session.commit() def __repr__(self): return "<name: {}>".format(self.name)
class ReplayStats(db.Model): __tablename__ = 'stats' id = db.Column(db.Integer, primary_key=True, autoincrement=True) created_at = db.Column(db.DateTime, nullable=False, server_default=func.now()) replay_id = db.Column(db.Integer, db.ForeignKey('replay.id', ondelete='CASCADE')) username = db.Column(db.String(255), nullable=False) eliminations = db.Column(db.Integer, default=False, nullable=False) accuracy = db.Column(db.Float, default=False, nullable=False) assists = db.Column(db.Integer, default=False, nullable=False) weapon_damage = db.Column(db.Integer, default=False, nullable=False) other_damage = db.Column(db.Integer, default=False, nullable=False) revives = db.Column(db.Integer, default=False, nullable=False) damage_taken = db.Column(db.Integer, default=False, nullable=False) damage_structures = db.Column(db.Integer, default=False, nullable=False) materials_gathered = db.Column(db.Integer, default=False, nullable=False) materials_used = db.Column(db.Integer, default=False, nullable=False) total_traveled = db.Column(db.Integer, default=False, nullable=False) position = db.Column(db.Integer, default=False, nullable=False) replay = db.relationship("Replay", backref="ReplayStats") @hybrid_property def died(self): return any(i for i in self.replay.elimination_events if i.eliminated == self.username and not i.knocked) @hybrid_property def knocks(self): return len([ i for i in self.replay.elimination_events if i.eliminator == self.username and i.knocked ]) @hybrid_property def knocked(self): return len([ i for i in self.replay.elimination_events if i.eliminated == self.username and i.knocked ]) @hybrid_property def winner(self): return self.position == 1 def __init__(self, replay_id, username, stats, team_stats): self.replay_id = replay_id self.username = username self.eliminations = stats['eliminations'] self.accuracy = stats['accuracy'] self.assists = stats['assists'] self.weapon_damage = stats['weapon_damage'] self.other_damage = stats['other_damage'] self.revives = stats['revives'] self.damage_taken = stats['damage_taken'] self.damage_structures = stats['damage_structures'] self.materials_gathered = stats['materials_gathered'] self.materials_used = stats['materials_used'] self.total_traveled = stats['total_traveled'] self.position = team_stats['position'] def __json__(self): return [ 'replay_id', 'username', 'eliminations', 'accuracy', 'assists', 'weapon_damage', 'other_damage', 'revives', 'damage_taken', 'damage_structures', 'materials_gathered', 'materials_used', 'total_traveled', 'position', 'died', 'knocks', 'knocked', 'winner' ]
class Application(db.Model): __tablename__ = "applications" id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) domain = db.Column(db.String(128), nullable=False) certificate = db.Column(db.String(128), nullable=False) contact_firstname = db.Column(db.String(128), nullable=True) contact_lastname = db.Column(db.String(128), nullable=True) contact_email = db.Column(db.String(128), nullable=True) contact_streetaddress = db.Column(db.String(128), nullable=True) contact_homecountry = db.Column(db.String(128), nullable=True) contact_phonenumber = db.Column(db.String(128), nullable=True) contact_company_name = db.Column(db.String(128), nullable=True) education_highest_degree = db.Column(db.String(128), nullable=True) education_year = db.Column(db.String(128), nullable=True) education_school = db.Column(db.String(128), nullable=True) education_city = db.Column(db.String(128), nullable=True) education_country = db.Column(db.String(128), nullable=True) general_main_language = db.Column(db.String(128), nullable=True) general_coding_years = db.Column(db.Integer(), nullable=True) general_coding_languages = db.Column(db.String(256), nullable=True) general_industry = db.Column(db.String(128), nullable=True) requirements_project_name_1 = db.Column(db.String(128), nullable=True) requirements_project_description_1 = db.Column(db.String(512), nullable=True) requirements_project_start_date_1 = db.Column(db.String(128), nullable=True) requirements_project_start_date_2 = db.Column(db.String(128), nullable=True) requirements_responsible = db.Column(db.String(128), nullable=True) requirements_accountable = db.Column(db.String(128), nullable=True) requirements_consulted = db.Column(db.String(128), nullable=True) requirements_informed = db.Column(db.String(128), nullable=True) requirements_project_company_1 = db.Column(db.String(128), nullable=True) requirements_project_reference_name_1 = db.Column(db.String(128), nullable=True) requirements_project_reference_email_1 = db.Column(db.String(128), nullable=True) requirements_project_reference_phonenumber_1 = db.Column(db.String(128), nullable=True) terms_agree = db.Column(db.String(128), nullable=True) status = db.Column(db.String(128), nullable=True) def __init__(self, **kwargs): super(Application, self).__init__(**kwargs) def to_json(self): return { 'id': self.id, 'domain': self.domain, 'certificate': self.certificate, 'contact_firstname': self.contact_firstname, 'contact_lastname': self.contact_lastname, 'contact_email': self.contact_email, 'contact_streetaddress': self.contact_streetaddress, 'contact_homecountry': self.contact_homecountry, 'contact_phonenumber': self.contact_phonenumber, 'contact_company_name': self.contact_company_name, "education_highest_degree": '', "education_year": self.education_year, "education_school": self.education_school, "education_city": self.education_city, "education_country": self.education_country, "general_main_language": self.general_main_language, "general_coding_years": self.general_coding_years, "general_coding_languages": self.general_coding_languages, "general_industry": self.general_industry, "requirements_project_name_1": self.requirements_project_name_1, "requirements_project_description_1": self.requirements_project_description_1, "requirements_project_start_date_1": self.requirements_project_start_date_1, "requirements_project_start_date_2": self.requirements_project_start_date_2, "requirements_responsible": self.requirements_responsible, "requirements_accountable": self.requirements_accountable, "requirements_consulted": self.requirements_consulted, "requirements_informed": self.requirements_informed, "requirements_project_company_1": self.requirements_project_company_1, "requirements_project_reference_name_1": self.requirements_project_reference_name_1, "requirements_project_reference_email_1": self.requirements_project_reference_email_1, "requirements_project_reference_phonenumber_1": self.requirements_project_reference_phonenumber_1, "terms_agree": self.terms_agree, "status": self.status }
class TenantSubscription(db.Model): __tablename__ = 'tenant_subscription' id = db.Column(db.Integer, primary_key=True, autoincrement=True) effective_from = db.Column(db.DateTime) effective_to = db.Column(db.DateTime) auto_renew = db.Column(db.Boolean, default=True) status = db.Column(db.Enum("Active", "Inactive", "Suspended"), default='Active') created_at = db.Column(db.DateTime) created_by = db.Column(db.String(50)) updated_at = db.Column(db.DateTime) updated_by = db.Column(db.String(50)) is_active = db.Column(db.Boolean, default=True) is_deleted = db.Column(db.Boolean, default=False) tenant_id = db.Column(db.Integer, ForeignKey('tenant.id')) tenant = relationship("Tenant", backref="tenant_subscription") membership_plan_id = db.Column(db.Integer, ForeignKey('membership_plan.id')) membershipPlan = relationship("MembershipPlan", backref="tenant_subscription") def __init__(self, id=None, effective_from="", effective_to="", status="", tenant_id=None, membership_plan_id=None, created_by="", created_at="", is_active="", is_deleted=""): self.id = id self.effective_from = effective_from self.effective_to = date.today() self.status = status self.tenant_id = tenant_id self.membership_plan_id = membership_plan_id self.created_at = created_at self.created_by = created_by @classmethod def get(cls, id: int): return TenantSubscription.query.get(id) @classmethod def all(cls): return cls.query.filter_by(is_active=True, is_deleted=False).order_by(cls.created_at) def to_json(self): return json.loads( json.dumps( { "id": self.id, "effective_from": self.effective_from, "effective_to": self.effective_to, "auto_renew": self.auto_renew, "status": self.status, "tenant_id": self.tenant_id, "membership_plan_id": self.membership_plan_id, "created_by": self.created_by, "created_at": self.created_at, "updated_at": self.updated_at, "updated_by": self.updated_by, "is_active": self.is_active }, default=default_proc)) def save(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() def exists(self, id): return db.session.query(db.exists().where(id == id)).scalar() def delete(self): if self.is_deleted: return Response.createFailResponse(self, ResponseMessages.not_found, HTTPStatus.NO_CONTENT) self.is_deleted = True db.session.commit() def __repr__(self): return "<name: {}>".format(self.name)
class users(db.Model): """This class represents the users table.""" __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_name = db.Column(db.String(200)) last_name = db.Column(db.String(200)) address = db.Column(db.String(200)) username = db.Column(db.String(200)) encrypted_password = db.Column(db.String(200)) temp_password = db.Column(db.String(200)) isreset_password = db.Column(db.Boolean, default=True) mobile = db.Column(db.String(200)) ismobile_verified = db.Column(db.Boolean, default=True) email = db.Column(db.Integer) isemail_verified = db.Column(db.Boolean, default=False) created_at = db.Column(db.TIMESTAMP) created_by = db.Column(db.String(200)) updated_at = db.Column(db.TIMESTAMP) updated_by = db.Column(db.String(200)) is_active = db.Column(db.Boolean, default=True) is_deleted = db.Column(db.Boolean, default=False) def __init__(self, id=None, first_name="", last_name="", address="", username="", encrypted_password="", temp_password="", mobile="", email="", isemail_verified="", ismobile_verified="", created_by=""): """initialize with id.""" self.id = id self.first_name = first_name self.last_name = last_name self.address = address self.username = username self.encrypted_password = encrypted_password self.temp_password = temp_password self.mobile = mobile self.email = email self.created_at = datetime.now() self.created_by = created_by @classmethod def get(cls, id: int): """ Get a users for a given id. :param id: the id of the name to retrieve :return: the users """ return users.query.get(id) @classmethod def all(cls, search_data=None): """ Get all available users. :return: list with all users """ if search_data != None: return cls.query.filter_by( is_active=True, is_deleted=False).filter( cls.first_name.ilike('%' + search_data + '%') | cls.last_name.ilike('%' + search_data + '%') | cls.address.ilike('%' + search_data + '%') | cls.username.ilike('%' + search_data + '%') | cls.email.ilike('%' + search_data + '%')).order_by( cls.created_at.desc()) else: return cls.query.filter_by(is_active=True, is_deleted=False).order_by( cls.created_at.desc()) def to_json(self): """ Convert a name object to JSON :return: the name JSON representation """ return json.loads( json.dumps( { "id": self.id, "first_name": self.first_name, "last_name": self.last_name, "address": self.address, "username": self.username, "mobile": self.mobile, "email": self.email, "created_by": self.created_by, "created_at": self.created_at, "updated_by": self.updated_by, "updated_at": self.updated_at, "is_active": self.is_active }, default=default_proc)) def save(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() def exists(self, id): return db.session.query(db.exists().where(id == id)).scalar() def get_user(self, username): query = 'SELECT * FROM users WHERE username ilike :username'.format( table_name=self.__tablename__) params = {"username": username} with db.engine.connect() as con: result = con.execute(text(query), **params) return result.first() def get_email(self, email): query = 'SELECT * FROM users WHERE email ilike :email'.format( table_name=self.__tablename__) params = {"email": email} with db.engine.connect() as con: result = con.execute(text(query), **params) return result.first() def delete(self): if self.is_deleted: return Response.createFailResponse(self, ResponseMessages.not_exist, HTTPStatus.NO_CONTENT) self.is_deleted = True db.session.commit() def __repr__(self): return "<username: {}>".format(self.username)
class User(db.Model): id = db.Column(db.Integer, primary_key=True) password_hash = db.Column(db.String(200), nullable=False) created_on = db.Column(db.DateTime, nullable=False, default=datetime.now) last_login = db.Column(db.DateTime) is_active = db.Column(db.Boolean, default=True) is_admin = db.Column(db.Boolean, default=False) email_verified = db.Column(db.Boolean, default=False) username = db.Column(db.String(30), nullable=False, unique=True, index=True) email = db.Column(db.String(40), nullable=False, unique=True) first_name = db.Column(db.String(30)) last_name = db.Column(db.String(30)) country = db.Column(db.String(3)) birthdate = db.Column(db.DateTime) def __repr__(self): return f'<User: {self.username}>' @property def password(self): raise AttributeError('password not readable') @password.setter def password(self, password): self.password_hash = generate_password_hash(password, method='sha256') def check_password(self, password) -> bool: return check_password_hash(self.password_hash, password) @property def full_name(self) -> str: return ' '.join(self.first_name, self.last_name) @classmethod def create_user(cls, **kwargs): user = cls(**kwargs) db.session.add(user) db.session.commit() return user
class Tenant(db.Model): """This class represents the tenant table.""" __tablename__ = 'tenant' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.Text) email = db.Column(db.Text, unique=True) company_name = db.Column(db.Text) mobile = db.Column(db.Numeric(precision=10)) country = db.Column(db.Text) language = db.Column(db.Text) company_size = db.Column(db.Text) primary_interest = db.Column(db.Text) created_at = db.Column(db.TIMESTAMP) created_by = db.Column(db.Text) updated_at = db.Column(db.Date) updated_by = db.Column(db.Text) isEmailValidated = db.Column(db.Boolean(), default=False) isActive = db.Column(db.Boolean(), default=True) isDeleted = db.Column(db.Boolean(), default=False) def __init__(self, id=None, name="", email="", created_by="", updated_at="", updated_by="", company_name="", mobile=None, country="", language="", company_size="", primary_interest=""): """initialize with id.""" self.id = id self.name = name self.email = email self.company_name = company_name self.mobile = mobile self.country = country self.language = language self.company_size = company_size self.primary_interest = primary_interest self.created_at = datetime.now() self.created_by = created_by self.updated_by = updated_by @classmethod def get(cls, id: int): """ Get a tenant for a given ID. :param id: the ID of the tenant to retrieve :return: the tenant """ return Tenant.query.get(id) @classmethod def all(cls, includeDeleted='False'): """ Get all available tenant. :return: list with all tenant """ if includeDeleted == 'True': return cls.query.order_by(cls.created_at.desc()) return cls.query.filter_by(isDeleted=False).order_by( cls.created_at.desc()) def to_json(self): """ Convert a Tenant object to JSON :return: the Tenant JSON representation """ return json.loads( json.dumps( { "id": self.id, "name": self.name, "email": self.email, "company_name": self.company_name, "mobile": self.mobile, "country": self.country, "language": self.language, "company_size": self.company_size, "primary_interest": self.primary_interest, "created_at": self.created_at, "created_by": self.created_by, "updated_at": self.updated_at, "updated_by": self.updated_by, "isEmailValidated": self.isEmailValidated, "isActive": self.isActive, "isDeleted": self.isDeleted }, default=default_proc)) def save(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() def exists(self, id): return db.session.query(db.exists().where(Tenant.id == id)).scalar() def delete(self): if self.isDeleted: abort(404) self.isDeleted = True db.session.commit() def __repr__(self): return "<Tenant: {}>".format(self.name)