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)