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)
