class InsuranceSubclass(db.Model):
__tablename__ = 'insurance_subclass'
class_code = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
parent_class = db.Column(db.Integer, db.ForeignKey(
'insurance_class.class_id', ondelete='CASCADE', onupdate='CASCADE'))
acronym = db.Column(db.String(50), nullable=True)
def __init__(self, class_code, name, parent_class, acronym):
self.name = name
self.class_code = class_code
self.parent_class = parent_class
self.acronym = acronym
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
@classmethod
def get_class_by_id(cls, code):
subclass = cls.query.filter_by(class_code=code).first()
return subclass
@classmethod
def get_acronym(cls, id):
subclass = cls.query.filter_by(class_code=id).first()
return subclass.acronym
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String())
def __init__(self, username, password):
self.username = username
self.password = password
def json(self):
return {"id": self.id, "username": self.username}, 200
# Method to save user to DB
def save_to_db(self):
db.session.add(self)
db.session.commit()
# Method to remove user from DB
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
# Class method which finds user from DB by username
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
# Class method which finds user from DB by id
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class UsersModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), nullable=False)
location = db.relationship('LocationsModel', backref='user', uselist=False)
passInfo = db.relationship('PassesModel', backref='user', uselist=False)
favorites = db.Column(db.Text, nullable=False)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
self.favorites = '[]'
def save_to_db(self):
db.session.add(self)
db.session.commit()
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_user_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def update_favorites(cls, _id, new_fav):
user = cls.query.filter_by(id=_id).first()
user.favorites = new_fav
db.session.commit()
# Checks whether the user_id has favorited target_id
# If so, returns true, else false
@classmethod
def is_fav(cls, user_id, target_id):
user = cls.query.filter_by(id=user_id).first()
is_fav = False
fav_list = json.loads(user.favorites)
for fav in fav_list:
if (int(fav["key"]) == target_id):
is_fav = True
return is_fav
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True)
email = db.Column(db.String(100), unique=False)
password = db.Column(db.String(80))
class PolicyPayments(db.Model):
"""
Describes all the transactions for a particular child policy, for both credit(payments) and debit(refunds)
"""
__tablename__ = 'policy_payments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# transaction type can either be mpesa, bankers cheque, refund
transaction_type = db.Column(db.String(10))
amount = db.Column(db.Float, nullable=False)
customer_no = db.Column(db.String(50))
child_policy_id = db.Column(
db.Integer,
db.ForeignKey('child_policy.id',
ondelete='CASCADE',
onupdate='CASCADE'))
next_date = db.Column(db.DateTime)
amount_due = db.Column(db.Float, nullable=False, default=0)
# could be the mpesa code, or cheque number
transaction_code = db.Column(db.String(25))
date_paid = db.Column(db.DateTime, default=db.func.now())
def __init__(self, transaction_type, amount, customer_no, child_policy_id,
next_date, amount_due, transaction_code):
self.transaction_type = transaction_type
self.amount = amount
self.customer_no = customer_no
self.child_policy_id = child_policy_id
self.next_date = next_date
self.amount_due = amount_due
self.transaction_code = transaction_code
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.remove(self)
db.session.commit()
@classmethod
def total_amount_paid(cls, child_id):
"""
Get total amount paid for a particular child policy
"""
amounts = [
t.amount for t in cls.query.filter_by(child_policy=child_id).all()
]
return sum(amounts)
@classmethod
def get_payments_history(cls, child_id):
return [
installment.serialize()
for installment in cls.query.filter_by(child_id=child_id).all()
]
class CompanyModel(db.Model, Model):
"""
CompanyModel Class
This class contains only CompanyModel methods and represents the companies table in database.
"""
__tablename__ = 'companies'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
position = db.Column(db.String(100), nullable=False)
assignments = db.Column(db.String(1000))
started_at = db.Column(db.Date(), nullable=False, default=datetime.date.today())
ended_at = db.Column(db.Date())
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
products = db.relationship('ProductModel', lazy='dynamic')
presentations = db.relationship('PresentationModel', lazy='dynamic')
def __init__(self, name: str, position: str, assignments: str, started_at: datetime, segment_id: int,
ended_at: datetime = None, _id: int = None) -> None:
"""
Loads a CompanyModel.
"""
self.id = _id
self.name = name
self.position = position
self.assignments = assignments
self.started_at = string_to_date(started_at)
self.ended_at = string_to_date(ended_at) if ended_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a CompanyModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'position': self.position,
'assignments': self.assignments,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None,
'segment': {'id': self.segment.id, 'name': self.segment.name},
'products': [product.json() for product in self.products.all()],
'presentations': [presentation.json() for presentation in self.presentations.all()]
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced CompanyModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'position': self.position,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None
}
class Tags(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String(), nullable=True)
def __init__(self, name, description):
self.name = name
self.description = description
class SkillModel(db.Model, Model):
"""
SkillModel Class
This class contains only SkillModel methods and represents the skills table in database.
"""
__tablename__ = 'skills'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False, unique=True)
description = db.Column(db.String(1000), nullable=False)
level = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today(),
unique=True)
segment_id = db.Column(db.Integer,
db.ForeignKey('segments.id'),
nullable=False,
default=1)
segment = db.relationship('SegmentModel')
def __init__(self,
name: str,
description: str,
level: int,
segment_id: int,
_id: int = None) -> None:
"""
Loads a SkillModel.
"""
self.id = _id
self.name = name
self.description = description
self.level = level
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a SkillModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'description': self.description,
'level': self.level,
'created_at': self.created_at.isoformat(),
'segment': {
'id': self.segment.id,
'name': self.segment.name
}
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced SkillModel as a json format.
"""
return {'id': self.id, 'name': self.name, 'level': self.level}
class ProgressModel(db.Model):
__tablename__ = "progress"
progress_id = db.Column(db.String(36), primary_key=True)
allocation_id = db.Column(db.String(36), db.ForeignKey('allocations.allocation_id', onupdate="CASCADE",
ondelete="CASCADE"))
date = db.Column(db.Date)
document = db.Column(db.String(50))
comments = db.Column(db.Text)
marks = db.Column(db.Integer)
def __init__(self, progress_id, allocation_id, date, document, comments, marks):
self.progress_id = progress_id
self.allocation_id = allocation_id
self.date = date
self.document = document
self.comments = comments
self.marks = marks
def serialize(self):
"""return json formatted data"""
return {
"progress_id": self.progress_id,
"allocation_id": self.allocaiton_id,
"date": self.date,
"document": self.document,
"comments": self.comments,
"marks": self.marks
}, 200
def add_progress(self):
db.session.add(self)
db.session.commit()
@staticmethod
def update_progress():
db.session.commit()
def remove_progress(self):
db.session.delete(self)
db.session.commit()
@classmethod
def fetch_progress_by_id(cls, allocation_id):
progress_rows = cls.query.filter_by(allocation_id=allocation_id)
all_progress = [{
"progress_id": progress.progress_id,
"allocation_id": progress.allocation_id,
"date": progress.date,
"document": progress.document,
"comments": progress.comments,
"marks": progress.marks
} for progress in progress_rows]
return all_progress
@classmethod
def fetch_progress_by_progress_id(cls, progress_id):
return cls.query.filter_by(progress_id=progress_id).first()
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
store_id = db.Column(db.Integer, db.ForeignKey('store.id'))
item_image = db.Column(db.String, nullable=True)
item_cover = db.Column(db.String, nullable=True)
name = db.Column(db.String(20), nullable=False)
detail = db.Column(db.String(300), nullable=True)
date_Added = db.Column(db.String, nullable=True)
cost = db.Column(db.Integer, nullable=False)
number_of_items = db.Column(db.Integer, nullable=False)
class Pages(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String(), nullable=True)
content = db.Column(db.String(), nullable=True)
def __init__(self, name, description, content):
self.name = name
self.description = description
self.content = content
class GraduationModel(db.Model, Model):
"""
GraduationModel Class
This class contains only GraduationModel methods and represents the graduations table in database.
"""
__tablename__ = 'graduations'
id = db.Column(db.Integer, primary_key=True)
course = db.Column(db.String(50), nullable=False, unique=True)
institution = db.Column(db.String(100), nullable=False, unique=True)
started_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today(),
unique=True)
ended_at = db.Column(db.Date())
segment_id = db.Column(db.Integer,
db.ForeignKey('segments.id'),
nullable=False,
default=1)
segment = db.relationship('SegmentModel')
def __init__(self,
course: str,
institution: str,
started_at: datetime,
segment_id: int,
ended_at: datetime = None,
_id: int = None) -> None:
"""
Loads a GraduationModel.
"""
self.id = _id
self.course = course
self.institution = institution
self.started_at = string_to_date(started_at)
self.ended_at = string_to_date(ended_at) if ended_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a GraduationModel as a json format.
"""
return {
'id': self.id,
'course': self.course,
'institution': self.institution,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None,
'segment': {
'id': self.segment.id,
'name': self.segment.name
}
}
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
name = db.Column(db.String(20), unique=False, nullable=False)
surname = db.Column(db.String(20), unique=False, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Posts', backref='author', lazy=True)
def __repr__(self):
return f'Users("{self.username}", "{self.email}", "{self.password}")'
class Categories(db.Model):
id = db.Column(db.Integer, primary_key=True)
postid = db.relationship('Posts',
backref='category',
lazy=True,
order_by="Posts.id.desc()")
name = db.Column(db.String(), nullable=False)
description = db.Column(db.String(), nullable=True)
def __init__(self, name, description):
self.name = name
self.description = description
class PresentationModel(db.Model, Model):
"""
PresentationModel Class
This class contains only PresentationModel methods and represents the presentations table in database.
"""
__tablename__ = 'presentations'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
performed_at = db.Column(db.Date(), nullable=False, default=datetime.date.today())
city = db.Column(db.String(250), nullable=False)
state = db.Column(db.String(250))
country = db.Column(db.String(250), nullable=False)
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
company_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
company = db.relationship('CompanyModel')
def __init__(self, name: str, performed_at: datetime, city: str, country: str, segment_id: int, state: str = None,
company_id: int = None, _id: int = None) -> None:
"""
Loads a PresentationModel.
"""
self.id = _id
self.name = name
self.performed_at = string_to_date(performed_at)
self.city = city
self.state = state if state else None
self.country = country
self.segment_id = segment_id
self.company_id = company_id
def json(self) -> dict:
"""
Retruns a PresentationModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'performed_at': self.performed_at.isoformat(),
'city': self.city,
'state': self.state if self.state else None,
'country': self.country,
'segment': {'id': self.segment.id, 'name': self.segment.name},
'company': {'id': self.company.id, 'name': self.company.name} if self.company else None
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced PresentationModel as a json format.
"""
return {'id': self.id, 'name': self.name, 'performed_at': self.performed_at.isoformat()}
class Awards(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id",
ondelete="CASCADE"))
award_title = db.Column(db.String(50), nullable=False)
award_desc = db.Column(db.String(400))
create_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, user_id, award_title="", award_desc=""):
self.user_id = user_id
self.award_title = award_title
self.award_desc = award_desc
class IndividualCustomer(db.Model):
"""
Individual customer user
linked to the UserProfile
"""
# ToDo: Serialize the individual customer data
__tablename__ = 'individual_customer'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
customer_number = db.Column(db.String(50))
user_id = db.Column(db.Integer, db.ForeignKey(
'user.id', ondelete='CASCADE', onupdate='CASCADE'))
salutation = db.Column(db.String(10), nullable=False)
def __repr__(self):
return f"{self.user}"
def __init__(self, user_id, customer_number, salutation):
self.user_id = user_id
self.salutation = salutation
self.customer_number = customer_number
def serialize(self):
customer_profile = {
"customer_number": self.customer_number,
"salutation": self.salutation
}
customer_profile.update(self.user.serialize())
return customer_profile
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_customer_by_user_id(cls, uid):
return cls.query.filter_by(user_id=uid).first()
@classmethod
def get_customer_number(cls, uid):
customer = cls.query.filter_by(user_id=uid).first()
return customer.customer_number
class AttendanceModel(db.Model):
__tablename__ = "attendance"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
nullable=False,
)
course_name = db.Column(db.String())
percentage = db.Column(db.String())
ratio = db.Column(db.String())
def __init__(self, user_id, course_name, percentage, ratio):
self.user_id = user_id
self.course_name = course_name
self.percentage = percentage
self.ratio = ratio
def json(self):
return {
"id": self.id,
"user_id": self.user_id,
"course_name": self.course_name,
"percentage": self.percentage,
"ratio": self.ratio
}, 200
# Method to save user to DB
def save_to_db(self):
db.session.add(self)
db.session.commit()
# Method to remove user from DB
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
# Class method which finds user from DB by username
@classmethod
def find_course_by_userid(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
# Class method which finds user from DB by id
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def deleteall(cls):
records = cls.query.all()
db.session.delete(records)
db.session.commit()
class Education(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id",
ondelete="CASCADE"))
school_name = db.Column(db.String(100), nullable=False)
major = db.Column(db.String(50), nullable=False)
status = db.Column(db.String(20), nullable=False)
create_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, user_id, school_name="", major="", status="attending"):
self.user_id = user_id
self.school_name = school_name
self.major = major
self.status = status
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False, unique=True)
comment = db.Column(db.String(200))
price = db.Column(db.Float, nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('products', lazy=True))
def __init__(self, name, comment, price, category_id):
self.name = name
self.comment = comment
self.price = price
self.category_id = category_id
class Driver(db.Model):
"""
Store driver details linked to a particular vehicle
"""
__tablename__ = 'driver'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
gender = db.Column(db.String(1))
# we need to store the user mobile number
# for subsequent communication
phone = db.Column(db.BIGINT, unique=True)
birth_date = db.Column(db.DateTime)
driver = db.relationship("VehicleDetails", backref="driver")
def __init__(self, first_name, last_name, gender, phone, birth_date):
self.first_name = first_name
self.last_name = last_name
self.gender = gender
self.phone = phone
self.birth_date = birth_date
def serialize(self):
return {
"first_name": self.first_name,
"last_name": self.last_name,
"phone": self.phone,
"birth_date": self.birth_date.strftime('%m/%d/%Y')
}
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.remove(self)
db.session.commit()
@classmethod
def get_driver_by_id(cls, id):
driver = cls.query.filter_by(id=id).first()
return driver
class UserModel(db.Model, Model):
"""
UserModel Class
This class contains only UserModel methods and represents the users table in database.
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(250), nullable=False)
created_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today())
updated_at = db.Column(db.Date())
def __init__(self,
_id: int,
username: str,
password: str,
created_at: datetime = None,
updated_at: datetime = None) -> None:
"""
Loads a UserModel.
"""
self.id = _id
self.username = username
self.password = password
self.created_at = created_at
self.updated_at = updated_at
def json(self) -> dict:
"""
Retruns a UserModel as a json format.
"""
return {
'username': self.username,
'created_at': self.created_at.isoformat(),
'updated_at':
self.updated_at.isoformat() if self.updated_at else None
}
@classmethod
def find_by_username(cls, username: str) -> Model:
"""
Returns a user found by username there is saved in database.
"""
return cls.query.filter_by(username=username).first()
class County(db.Model):
__tablename__ = 'county'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
county_name = db.Column(db.String(50), unique=True, nullable=False)
constituency = db.relationship("Constituency", backref="county")
ward = db.relationship("Ward", backref="county")
def __init__(self, county_name):
self.county_name = county_name
def serialize(self):
return {"id": self.id, "name": self.county_name}
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_county_by_name(cls, name):
county = cls.query.filter_by(county_name=name).first()
return county.id
@classmethod
def get_county_by_id(cls, id):
county = cls.query.filter_by(id=id).first()
return county
@classmethod
def get_all_counties(cls):
counties = [c.serialize() for c in cls.query.all()]
return counties
class Levies(db.Model):
__tablename__ = 'levies'
"""Contains levies for a particular child policy"""
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
name = db.Column(db.String(100))
rate = db.Column(db.Float, nullable=False)
def __init__(self, name, rate):
self.name = name
self.rate = rate
def __repr__(self):
return f"{self.name}"
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_levies(cls):
levies = cls.query.all()
return levies
class Historico(db.Model):
idhistorico = db.Column(db.Integer,
primary_key=True,
autoincrement=False,
nullable=False,
unique=False)
idcidade = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
idindicador = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
ano = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
valor = db.Column(db.String(200))
def __init__(self, idcidade, idindicador, ano, valor):
self.idcidade = idcidade
self.idindicador = idindicador
self.ano = ano
self.valor = valor
class ArchivesModel(db.Model):
__tablename__ = "archives"
archive_id = db.Column(db.String(36), primary_key=True)
student_adm = db.Column(db.Integer)
student_name = db.Column(db.String(50))
supervisor_name = db.Column(db.String(50))
project_code = db.Column(db.String(50))
date_registered = db.Column(db.DateTime)
due_date = db.Column(db.DateTime)
def __init__(self, archive_id, student_adm, student_name, supervisor_name,
project_code, date_registered, due_date):
self.archive_id = archive_id
self.student_adm = student_adm
self.student_name = student_name
self.supervisor_name = supervisor_name
self.project_code = project_code
self.date_registered = date_registered
self.due_date = due_date
def serialize(self):
return {
"student_adm": self.student_adm,
"student_name": self.student_name,
"supervisor_name": self.supervisor_name,
"project_code": self.project_code,
"date_registered": self.date_registered,
"due_date": self.due_date
}, 200
def add_archive(self):
db.session.add(self)
db.session.commit()
@classmethod
def fetch_all_archives(cls):
archive_rows = cls.query.all()
all_archives = [{
"student_adm": archive.student_adm,
"student_name": archive.student_name,
"supervisor_name": archive.supervisor_name,
"project_code": archive.project_code,
"date_registered": archive.date_registered,
"due_date": archive.due_date
} for archive in archive_rows]
return all_archives
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(100), nullable=False)
fullname = db.Column(db.String(30), nullable=False)
register_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, email, password, fullname):
self.email = email
self.set_password(password)
self.fullname = fullname
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class CertificationModel(db.Model, Model):
"""
CertificationModel Class
This class contains only CertificationModel methods and represents the certifications table in database.
"""
__tablename__ = 'certifications'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
organization = db.Column(db.String(100), nullable=False, unique=True)
issued_at = db.Column(db.Date(), nullable=False, default=datetime.date.today(), unique=True)
expires_at = db.Column(db.Date())
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
def __init__(self, name: str, organization: str, issued_at: datetime, segment_id: int, expires_at: datetime = None,
_id: int = None) -> None:
"""
Loads a CertificationModel.
"""
self.id = _id
self.name = name
self.organization = organization
self.issued_at = string_to_date(issued_at)
self.expires_at = string_to_date(expires_at) if expires_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a CertificationModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'organization': self.organization,
'issued_at': self.issued_at.isoformat(),
'expires_at': self.expires_at.isoformat() if self.expires_at else None,
'segment': {'id': self.segment.id, 'name': self.segment.name}
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced CertificationModel as a json format.
"""
return {'id': self.id, 'name': self.name}
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String(), nullable=True)
content = db.Column(db.String(), nullable=True)
tags = db.relationship('Tags',
secondary=relations,
backref=db.backref('tag'))
categories = db.Column(db.Integer(),
db.ForeignKey('categories.id'),
nullable=True)
author = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable=True)
def __init__(self, name, description, content):
self.name = name
self.description = description
self.content = content
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
postid = db.relationship('Posts', backref='user', lazy=True)
account = db.Column(db.String(), nullable=False)
password_hash = db.Column(db.String(), nullable=False)
name = db.Column(db.String(), nullable=True)
introduction = db.Column(db.String(), nullable=True)
def __init__(self, account, password):
self.account = account
self.password_hash = generate_password_hash(password)
def change_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
