class AvailablePlayer(db.Model):
id = db.Column("id", db.Integer, primary_key=True)
player = db.Column(db.String(100), nullable=False)
flag_image = db.Column(db.String(20),
nullable=False,
default='default.jpg')
player_image = db.Column(db.String(20),
nullable=False,
default='static/images/default_headshot.jpg')
world_rank = db.Column(db.Integer, nullable=True, default="N/A")
odds = db.Column(db.String(20), nullable=False, default='N/A')
odds_int = db.Column(db.Integer, default=999999)
country = db.Column(db.String(50))
active = db.Column(db.Integer, default=0)
tee_time = db.Column(db.String(40))
pos = db.Column(db.String(5))
to_par = db.Column(db.String(100))
to_par_int = db.Column(db.Integer)
today = db.Column(db.String(50))
today_int = db.Column(db.Integer)
thru = db.Column(db.String(5))
holes_remaining = db.Column(db.Integer)
r1 = db.Column(db.Integer)
r2 = db.Column(db.Integer)
r3 = db.Column(db.Integer)
r4 = db.Column(db.Integer)
cut_projected = db.Column(db.Integer)
cut_final = db.Column(db.Integer)
drafted_flag = db.Column(db.Integer, default=0)
drafted_player = db.Column(db.Integer,
db.ForeignKey('DraftedPlayer.id'),
nullable=True)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey('profile.id', ondelete='CASCADE'),
nullable=False)
content = db.Column(db.String(280), nullable=False)
location = db.Column(db.String(40), nullable=True)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
image = db.Column(db.String(20), nullable=True)
comments = db.relationship('Comment',
cascade="all, delete-orphan",
backref='post')
likes = db.relationship('Profile',
secondary=likes,
lazy='subquery',
backref=db.backref('likes', lazy=True))
def add_image(self, image_data):
picture_file_name = save_image(image_data,
app.config['UPLOAD_FOLDER_POSTS_IMGS'],
(510, 515))
self.image = picture_file_name
def delete_image(self):
if self.image:
delete_image(app.config['UPLOAD_FOLDER_POSTS_IMGS'], self.image)
self.image = None
def __repr__(self):
return f"Post({self.id}, '{self.author_id}', '{self.content}', '{self.location}', '{self.date_posted}', '{self.image}')"
def __str__(self):
return f"Post(#{self.id})"
class GPMobile(db.Model):
__tablename__ = 'gp_mobile'
mobilePhone = db.Column(db.String(8), primary_key=True)
postalCode = db.Column(db.String(10), unique=False, nullable=False)
def __init__(self, **kwargs):
super(GPMobile, self).__init__(**kwargs)
class EquipmentTypeModel(db.Model, BaseModel):
# The name of the table at the data base.
__tablename__ = TableNames.S_EQUIPMENT_TYPE
# The table columns.
type_id = db.Column(db.String(50), primary_key=True)
description = db.Column(db.String(500), nullable=True)
equipments = db.relationship(RelationShip.EQUIPMENT,
backref="info",
cascade="save-update, merge, delete",
lazy=True)
def __repr__(self):
return "EquipmentTagsModel(type_id={})".format(self.type_id)
def to_dict(self):
"""
Convert EquipmentTagsModel into a dictionary, this way we can convert it to a JSON response.
:return: A clean dictionary form of this model.
"""
# convert columns to dict
dict_representation = super().to_dict()
# add additional values for the dictionary.
dict_representation["equipments"] = [
eq.to_dict() for eq in self.equipments
]
return dict_representation
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.svg")
password = db.Column(db.String(60), nullable=False)
courses = db.relationship("Course", backref="teacher", lazy=True)
def get_reset_token(self, expires_sec=86400):
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})"
def to_dict(self):
return dict(
id=self.id,
username=self.username,
email=self.email,
image_file=self.image_file,
)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
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 RolesRightsModel(db.Model, BaseModel):
# The name of the table at the data base.
__tablename__ = TableNames.T_ROLES_RIGHTS
# The table columns.
role_id = db.Column(db.String(50), db.ForeignKey(TableNames.S_ROLES + ".role_id"), primary_key=True)
right_id = db.Column(db.String(50), db.ForeignKey(TableNames.S_RIGHTS + ".right_id"), primary_key=True)
def __repr__(self):
return "RolesRights(role_id={}, right_id={})".format(self.role_id, self.right_id)
# Queries for this model.
@classmethod
def get_rights_by_role(cls, role_id: str):
"""
Get the a list of right ids for this role.
:param role_id: The role id.
:return: A list of right ids for this role.
"""
roles_rights: List[RolesRightsModel] = cls.find_by(role_id=role_id, get_first=False)
if roles_rights:
return [rr.right_id for rr in roles_rights]
return None
class Incident(db.Model):
__tablename__ = 'incident'
# Attributes
incidentID = db.Column(db.Integer, primary_key=True, autoincrement=True)
postalCode = db.Column(db.String(10), unique=False, nullable=False)
address = db.Column(db.String(200), unique=False, nullable=False)
description = db.Column(db.String(200), nullable=True)
#Will be computed based by address entered
longtitude = db.Column(db.String(120), unique=False, nullable=False)
latitude = db.Column(db.String(120), unique=False, nullable=False)
gpid = db.Column(db.Integer, db.ForeignKey('general_public.gpid'))
operatorID = db.Column(db.Integer, db.ForeignKey('operator.operatorid'))
timeStamp=db.Column(db.DateTime, nullable=False, default=sgtimestampnow)
# Relationships
# Association of proxy incident_assigned_to_relevant_agencies to releevant_agencies
emergencyType = db.relationship("EmergencyType", secondary=incident_has_emergencyType, backref="incidents")
assistanceType = db.relationship("AssistanceType", secondary=incident_request_assistanceType, backref="incidents")
relevantAgencies = association_proxy('incident_assigned_to_relevant_agencies', 'relevantAgency',creator=lambda relevantAgency: IncidentAssignedToRelevantAgencies(relevantAgency=relevantAgency))
operator = relationship("Operator", backref="incidents")
reportedUser = relationship("GeneralPublic", backref="reportedIncident")
# To access list of statues from incident, use incidentInstance.statues. Return a list of status objects
# to access derived table, from incident table use incidentInstance.incident_has_status or statusInstance.incidents
statuses = association_proxy('incident_has_status', 'status',creator=lambda status: IncidentHasStatus(status=status))
def __init__(self, **kwargs):
super(Incident, self).__init__(**kwargs)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(40), nullable=False, default='Not yet provided')
username = db.Column(db.String(21), unique=True, nullable=False)
email = db.Column(db.String(60), unique=True, nullable=False)
image_file = db.Column(db.String(20), nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
about = db.Column(db.Text, nullable=False, default='Not yet provided')
internet_points = db.Column(db.Integer, nullable=False, default=0)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=3600):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
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:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.full_name}', '{self.email}', '{self.image_file}', '{self.about[:16]}...')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"User('{self.username}')"
class Posts(db.Model):
sno = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.String(500))
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
slug = db.Column(db.String(30), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
class User(db.Model):
__tablename__ = 'user_t'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True)
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False)
createddate = db.Column(db.DateTime, default=datetime.utcnow)
modifieddate = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, email, first_name, last_name):
self.email = email
self.first_name = first_name
self.last_name = last_name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'email': self.email,
'first_name': self.first_name,
'last_name': self.last_name,
'createddate': dump_datetime(self.createddate),
'modifieddate': dump_datetime(self.modifieddate)
}
def __repr__(self):
return "<User '{}'>".format(self.first_name)
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),
unique=False,
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
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:
return None
return User.query.get(user_id)
def __repr__(self):
return "User('{}', '{}', '{}')".format(self.username, self.email,
self.image_file)
class Person(db.Model):
__tablename__ = 'person'
def __repr__(self):
return f"Person('{self.person_id}', '{self.birth_datetime}', '{self.race_concept_id}', '{self.ethnicity_concept_id}')"
person_id = db.Column(db.Integer(), primary_key=True) ##types.BIGINT(),
gender_concept_id = db.Column(db.Integer(),
default=None) ##types.INTEGER(),
year_of_birth = db.Column(db.Integer(), default=None) ##types.INTEGER(),
month_of_birth = db.Column(db.Integer(), default=None) ##types.INTEGER(),
day_of_birth = db.Column(db.Integer(), default=None) ##types.INTEGER(),
birth_datetime = db.Column(db.DateTime(), default=None) ##DateTime(),
race_concept_id = db.Column(db.Integer(), default=None) ##types.INTEGER(),
ethnicity_concept_id = db.Column(db.Integer(),
default=None) ##types.INTEGER(),
location_id = db.Column(db.Integer(), default=None) ##types.INTEGER(),
provider_id = db.Column(db.Integer(), default=None) ##types.INTEGER(),
care_site_id = db.Column(db.Integer(), default=None) ##types.INTEGER(),
person_source_value = db.Column(db.String(),
default=None) ##types.VARCHAR(length=255),
gender_source_value = db.Column(db.String(),
default=None) ##types.VARCHAR(length=255),
gender_source_concept_id = db.Column(db.Integer(),
default=None) ##types.INTEGER(),
race_source_value = db.Column(db.String(),
default=None) ##types.VARCHAR(length=50),
race_source_concept_id = db.Column(db.Integer(),
default=None) ##types.INTEGER(),
ethnicity_source_value = db.Column(
db.String(), default=None) ##types.VARCHAR(length=50),
ethnicity_source_concept_id = db.Column(db.Integer(),
default=None) ##types.INTEGER()})
class FileTransferredModel(db.Model, BaseModel):
# The name of the table at the data base.
__tablename__ = TableNames.T_TRANSFERRED_FILES
# The table columns.
id = db.Column(db.String(50), primary_key=True)
status_id = db.Column(
db.String(50), db.ForeignKey(TableNames.S_TRANSFERRED_STATUS + ".id"))
transferred_by = db.Column(db.String(50), unique=False, nullable=False)
transferred_at = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
def __repr__(self):
return "FileTransferredModel(id={}, status_id={}, transferred_by={}, transferred_at={})"\
.format(self.id, self.status_id, self.transferred_by, self.transferred_at)
def save(self):
if current_user:
self.transferred_by = current_user.username
else:
self.transferred_by = "Unknown"
super().save()
def update(self, status_id: str, transferred_at: datetime):
self.status_id = status_id
self.transferred_at = transferred_at
self.save()
class Contact(db.Model):
sno = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(20), nullable=False)
message = db.Column(db.String(150))
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
ph_no = db.Column(db.Integer)
class Stock(db.Model):
__tablename__ = "stocks"
ticker = db.Column(db.String(32), primary_key=True)
name = db.Column(db.String(128), nullable=False)
sticker = db.Column(db.Float, nullable=True)
margin = db.Column(db.Float, nullable=True)
avg_eps_growth = db.Column(db.Float, nullable=True)
qoq_eps_growth = db.Column(db.Float, nullable=True)
avg_sales_growth = db.Column(db.Float, nullable=True)
qoq_sales_growth = db.Column(db.Float, nullable=True)
sales = db.relationship('Revenues', backref='stock', lazy=True)
epss = db.relationship('EPS', backref='stock', lazy=True)
equity = db.relationship('Equity', backref='stock', lazy=True)
freecash = db.relationship('FreeCash', backref='stock', lazy=True)
def __init__(self, name, ticker, sticker=None, margin=None):
self.name = name
self.ticker = ticker.upper()
self.sticker = sticker
self.margin = margin
def to_json(self):
return {
'name': self.name,
'ticker': self.ticker,
'sticker': self.sticker,
'margin': self.margin,
'avgEpsGrowth': self.avg_eps_growth,
'qoqEpsGrowth': self.qoq_eps_growth,
'avgSalesGrowth': self.avg_sales_growth,
'qoqSalesGrowth': self.qoq_sales_growth
}
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True)
image = db.Column(db.Text(), default='index.png')
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
posts = db.relationship('Post', backref='user', lazy=True)
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60), nullable=False)
date_posted = db.Column(db.DateTime)
upload_file = db.Column(db.String(20), nullable=False)
description = db.Column(db.Text(1500), nullable=False)
optional_link = db.Column(db.String)
creators_num = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
last_editor = db.Column(db.String)
score_points_pool = db.Column(db.Integer, default=0)
score_points_pool_shuffled = db.Column(db.Integer, default=0)
score_pool_per_project = db.Column(db.Integer, default=0)
score_admin = db.Column(db.Integer, default=0)
score_admin_improvement = db.Column(db.Integer, default=0)
user_distinctions = db.Column(db.Integer, default=0)
admin_distinction = db.Column(db.Boolean, default=False)
comments = db.relationship('Comments', backref='project', lazy=True, cascade="all, delete")
date_posted_improvement = db.Column(db.DateTime)
title_improvement = db.Column(db.String(60))
upload_file_improvement = db.Column(db.String(20))
description_improvement = db.Column(db.Text(1500))
optional_link_improvement = db.Column(db.String)
def __repr__(self):
return f"Project('{self.title}', 'author_id={self.user_id}')"
class Business(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
coordinates = db.Column(db.String(100), nullable=True)
categories = db.Column(db.String(100), nullable=True)
def __repr__(self):
return f"Business('{self.name}')"
class post(db.Model):
id= db.Column(db.Integer, primary_key=True)
picture = db.Column(db.String(20),nullable = False)
title = db.Column(db.String(20), nullable = False)
description = db.Column(db.String(150))
author = db.Column(db.String(60))
postedBy = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class ToWatch(db.Model):
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(10), nullable=False)
name = db.Column(db.String(20), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"ToWatch('{self.name}')"
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)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return "User: {}, {}".format(self.username, self.email)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
message = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
def __repr__(self):
return f"Email('{self.email}', '{self.message}')"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
class Visitor(db.Model):
__tablename__ = 'visitor'
name = db.Column(db.String(25))
contact = db.Column(db.String(11))
place_from = db.Column(db.String(20))
timesheet = db.relationship('Timesheet_Visitor', backref='timelog')
activities = db.relationship('Activity', backref='activity')
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)
password = db.Column(db.String(60), nullable=False)
entry = db.relationship('graphData',backref='user', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.entry}')"
class Booking(db.Model):
id = db.Column(db.Integer, primary_key=True)
Day = db.Column(db.String(1), nullable=False)
Time = db.Column(db.String(5), nullable=False)
Name = db.Column(db.String(10), nullable=False)
def __repr__(self):
return f"User('{self.Day}','{self.Time}','{self.Name}')"
class Detail(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), unique=False, nullable=False)
address = db.Column(db.String(120), unique=False, nullable=False)
gender = db.Column(db.String(6), nullable=False)
phone_no = db.Column(db.Integer, nullable=False)
def __repr__(self):
return f"Detail('{self.name}', '{self.address}', '{self.gender}','{self.phone_no}')"
