class ClientDepartmentsDetailsRepo(Base): __tablename__ = 'client_department_details_m' department_id = db.Column(db.Integer, primary_key=True, autoincrement=True) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.client_id)) _function = db.Column(db.String(20), nullable=False) role = db.Column(db.String(20), nullable=False) location = db.Column(db.String(20), nullable=False) band = db.Column(db.String(10), nullable=False) EmployeeDetailsRepo = relationship("EmployeeDetailsRepo", cascade="all,delete", backref="ClientDepartmentsDetailsRepo", lazy='joined') def __repr__(self): return "<ClientDepartmentsDetailsRepo(department_id='{}',cycle_id='{}',_function='{}',role='{}',location='{}'," \ "band='{}')>".format(self.department_id, self.cycle_id, self._function, self.role, self.location, self.band) def get_json(self): body = { "department_id": self.department_id, "cycle_id": self.cycle_id, "function": self._function, "role": self.role, "location": self.location, "band": self.band } return body
class Superuser(BaseModel): __tablename__ = 'superusers' email = db.Column(db.String(255), nullable=False, unique=True) password_hash = db.Column(db.String(255), nullable=False) fullname = db.Column(db.String(255), nullable=True) last_login_at = db.Column(db.DateTime, nullable=True) activities = db.relationship('Activity', backref='superuser', cascade='all, delete-orphan') @property def password(self): raise AttributeError('password is not a readable attribue') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def is_authenticated(self): return True
class UserTagTable(db.Model): """ Initialize the user_tag_table from MySQL database +----------------+---------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +----------------+---------------+------+-----+---------+----------------+ | userID | int(11) | NO | | NULL | | | itemID | int(11) | NO | PRI | NULL | auto_increment | | Link | varchar(1000) | YES | | NULL | | | CreateTime | datetime | NO | | NULL | | | Tag | varchar(1000) | YES | | NULL | | | Title | varchar(1000) | YES | | NULL | | | LastUpdateTime | datetime | NO | | NULL | | +----------------+---------------+------+-----+---------+----------------+ """ userID = db.Column(db.Integer, unique=False, nullable=False, primary_key=False) itemID = db.Column(db.Integer, unique=True, nullable=False, primary_key=True) Link = db.Column(db.String(1000)) Tag = db.Column(db.String(1000)) Title = db.Column(db.String(1000)) CreateTime = db.Column(db.DateTime) LastUpdateTime = db.Column(db.DateTime)
class ClientRepo(Base): __tablename__ = 'client_table_m' client_id = db.Column(db.String(64), primary_key=True) client_name = db.Column(db.String(64), nullable=False) client_email_id = db.Column(db.String(64), nullable=False, unique=True) client_uri = db.Column(db.String(64)) cycle = relationship("ClientCycleRepo", backref='clientrepo', cascade="all,delete", lazy='dynamic') employee = relationship("EmployeeDetailsRepo", backref='clientrepo', cascade="all,delete", lazy='dynamic') ClientAdminRepo = relationship("ClientAdminRepo", backref='clientrepo', cascade="all,delete", lazy='dynamic') def __repr__(self): return "<Clients(client_id='{}',client_name='{}',client_email_id='{}',client_uri='{}')>".format( self.client_id, self.client_name, self.client_email_id, self.client_uri) def get_json(self): body = { "client_id": self.client_id, "client_name": self.client_name, "client_email_id": self.client_email_id, "client_uri": self.client_uri } return body
class EmployeRelationMapping(Base): __tablename__ = 'employee_relation_mapping_t' map_id = db.Column(db.Integer, primary_key=True, autoincrement=True) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id), nullable=False) pat_emp_id = db.Column(db.String(20), nullable=False) relation_id = db.Column(db.Integer, db.ForeignKey(UserRelationRepo.relation_id), nullable=False) target_emp_id = db.Column(db.String(20), nullable=False) AssessmentTestAnswers = relationship("AssessmentTestAnswers", cascade="all,delete", backref="EmployeRelationMapping", lazy='joined') FeedBackStatements = relationship("FeedBackStatements", cascade="all,delete", backref="EmployeRelationMapping", lazy='joined') def __repr__(self): return "<EmployeRelationMapping(map_id='{}',cycle_id='{}',pat_emp_id='{}',relation_id='{}'," \ "target_emp_id='{}')>".format(self.map_id, self.cycle_id, self.pat_emp_id, self.relation_id, self.target_emp_id) def get_json(self): body = { "map_id": self.map_id, "cycle_id": self.cycle_id, "pat_emp_id": self.pat_emp_id, "relation_id": self.relation_id, "target_emp_id": self.target_emp_id } return body
class Activity(BaseModel): __tablename__ = 'activities' channel = db.Column(db.String(255), nullable=True) description = db.Column(db.String(255), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE')) superuser_id = db.Column( db.Integer, db.ForeignKey('superusers.id', ondelete='CASCADE'))
class User(UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) uname = db.Column(db.String(80), unique=True) password_hash = db.Column(db.String(80)) email = db.Column(db.String(80), unique=True) phone = db.Column(db.String(20), unique=True) img = db.Column(db.String(80)) title = db.Column(db.Integer) confirmed = db.Column(db.Boolean, nullable=False, default=False) confirmed_on = db.Column(db.DateTime, nullable=True) def __init__(self, uname, password, email, phone=None, img=None, title=None, confirmed=False, confirmed_on=None): self.uname = uname self.password_hash = generate_password_hash(password) self.email = email self.phone = phone self.img = img self.title = title self.confirmed = confirmed self.confirmed_on = confirmed_on def serialize(self): return { "id": self.id, "uname": self.uname, "password": self.password_hash, "role": self.title, "email": self.email, "phone": self.phone, "img": self.img, "title": self.title, "confirmed": self.confirmed, "confirmed_on": self.confirmed_on } def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def get_user_by_id(id): return User.query.filter_by(id=id).first() def is_tourist(email): if UserModule.query.filter(email=email).count() > 0: return False return True
class ClientCycleRepo(Base): __tablename__ = 'client_cycle_details_m' cycle_id = db.Column(db.Integer, primary_key=True, autoincrement=True) client_id = db.Column(db.String(64), db.ForeignKey(ClientRepo.client_id), nullable=False) cycle_name = db.Column(db.String(64), nullable=False) created_date = db.Column(db.Date, nullable=False) from_date = db.Column(db.Date) to_date = db.Column(db.Date) is_active = db.Column(db.Boolean, default=True) departments = relationship("ClientDepartmentsDetailsRepo", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') EmployeRelationMapping = relationship("EmployeRelationMapping", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') ParticipantsAssessmentStatus = relationship("ParticipantsAssessmentStatus", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') IndividualScores = relationship("IndividualScores", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') CompetancyScores = relationship("CompetancyScores", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') ClientAdminRepo = relationship("ClientAdminRepo", cascade="all,delete", backref="clientcyclerepo", lazy='dynamic') def __repr__(self): return "<ClientCycleRepo(cycle_id='{}',client_id='{}',cycle_name='{}',from_date='{}',to_date='{}'," \ "is_active='{}')>".format(self.cycle_id, self.client_id, self.cycle_name, self.from_date, self.to_date, self.is_active) def get_json(self): body = { "cycle_id": self.cycle_id, "client_id": self.client_id, "cycle_name": self.cycle_name, "created_date": self.created_date, "from_date": self.from_date, "to_date": self.to_date, "is_active": self.is_active, } return body
class User(BaseModel): __tablename__ = 'users' fullname = db.Column(db.String(255), nullable=False) dob = db.Column(db.String(255), nullable=False) home_address = db.Column(db.String(255), nullable=True) work_address = db.Column(db.String(255), nullable=True) phone_number = db.Column(db.String(255), nullable=False) password_hash = db.Column(db.String(255), nullable=False) occupation = db.Column(db.String(255), nullable=True) status = db.Column(db.String(255), nullable=True) last_login_at = db.Column(db.DateTime, nullable=True) last_logout_at = db.Column(db.DateTime, nullable=True) activities = db.relationship('Activity', backref='user', cascade='all, delete-orphan') @property def password(self): raise AttributeError('password is not a readable attribue') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def is_anonymous(self): return False def get_id(self): return self.id
class House(db.Model): house_id = db.Column(db.Integer, primary_key=True) house_keeper = db.Column(db.Integer) year = db.Column(db.Integer) color = db.Column(db.String) house_name = db.Column(db.String(30)) def __init__(self, house_keeper, year, color, house_name): self.house_keeper = house_keeper self.year = year self.color = color self.house_name = house_name def get_houselist_by_year(year): houseList = House.query.filter_by(year=year).all() return houseList def get_house_by_id(house_id): house = House.query.filter_by(house_id=house_id).first() return house def get_house_by_housekeeper(hkid): house = House.query.filter_by(house_keeper=hkid).first() return house def serialize(self): return { "house_id": self.house_id, "house_keeper": self.house_keeper, "year": self.year, "color": self.color, "house_name": self.house_name }
class CompetancyScores(Base): __tablename__ = 'competancy_question_answer_score_t' id = db.Column(db.Integer, primary_key=True, autoincrement=True) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id)) emp_id = db.Column(db.String(20), db.ForeignKey(EmployeeDetailsRepo.emp_id)) competency_id = db.Column(db.Integer, db.ForeignKey(CompetencyTypeRepo.competency_id)) avg_self_score = db.Column(db.DECIMAL(4, 2)) avg_senior_score = db.Column(db.DECIMAL(4, 2)) avg_peer_score = db.Column(db.DECIMAL(4, 2)) avg_subordinates_score = db.Column(db.DECIMAL(4, 2)) avg_others_score = db.Column(db.DECIMAL(4, 2)) avg_respondants_score = db.Column(db.DECIMAL(4, 2)) gap_analysis_score = db.Column(db.DECIMAL(6, 2)) def __repr__(self): return "<CompetancyScores(id='{}')>".format(self.id) def get_json(self): body = { "id": self.id, "cycle_id": self.cycle_id, "emp_id": self.emp_id, "competency_id": self.competency_id, "avg_self_score": self.avg_self_score, "avg_senior_score": self.avg_senior_score, "avg_peer_score": self.avg_peer_score, "avg_subordinates_score": self.avg_subordinates_score, "avg_others_score": self.avg_others_score, "avg_respondants_score": self.avg_respondants_score, "gap_analysis_score": self.gap_analysis_score } return body
class IndividualScores(Base): __tablename__ = 'individual_question_answer_score_t' id = db.Column(db.Integer, primary_key=True, autoincrement=True) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id)) emp_id = db.Column(db.String(20), db.ForeignKey(EmployeeDetailsRepo.emp_id)) que_id = db.Column(db.Integer, db.ForeignKey(AssessmentQuestionsRepo.que_id)) self_score = db.Column(db.Integer) avg_senior_score = db.Column(db.DECIMAL(4, 2)) avg_peer_score = db.Column(db.DECIMAL(4, 2)) avg_subordinates_score = db.Column(db.DECIMAL(4, 2)) avg_respondants_score = db.Column(db.DECIMAL(4, 2)) def __repr__(self): return "<IndividualScores(id='{}')>".format(self.id) def get_json(self): body = { "id": self.id, "cycle_id": self.cycle_id, "emp_id": self.emp_id, "que_id": self.que_id, "self_score": self.self_score, "avg_senior_score": self.avg_senior_score, "avg_peer_score": self.avg_peer_score, "avg_subordinates_score": self.avg_subordinates_score, "avg_others_score": self.avg_others_score, "avg_respondants_score": self.avg_respondants_score } return body
class ParticipantsAssessmentStatus(Base): __tablename__ = 'participant_ass_status_t' id = db.Column(db.Integer, primary_key=True, autoincrement=True) emp_id = db.Column(db.String(20), db.ForeignKey(EmployeeDetailsRepo.emp_id)) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id)) is_respondant_selective = db.Column(db.Boolean, default=False) is_block_report = db.Column(db.Boolean, default=False) total_respondant_count = db.Column(db.Integer) seniors_count = db.Column(db.Integer) subordinates_count = db.Column(db.Integer) peer_count = db.Column(db.Integer) others_count = db.Column(db.Integer) ass_com_seniors_count = db.Column(db.Integer, default=0) ass_com_subordinates_count = db.Column(db.Integer, default=0) ass_com_peer_count = db.Column(db.Integer, default=0) ass_com_others_count = db.Column(db.Integer, default=0) ass_com_respondant_count = db.Column(db.Integer, default=0) completion_status_id = db.Column( db.Integer, db.ForeignKey(AssessmentCompletionStatusRepo.status_id), default=1) is_generate_report = db.Column(db.Boolean, default=False) def __repr__(self): return "<ParticipantsAssessmentStatus(id='{}')>".format(self.id)
class ClientAdminRepo(Base): __tablename__ = 'client_admin_details_m' id = db.Column(db.Integer, primary_key=True, autoincrement=True) cycle_id = db.Column(db.Integer, db.ForeignKey(ClientRepo.client_id)) client_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.client_id), nullable=False) emp_id = db.Column(db.String(64), db.ForeignKey(EmployeeDetailsRepo.emp_id), nullable=False) password_ = db.Column(db.Text) is_super_admin = db.Column(db.Boolean, default=True) def __repr__(self): return "<ClientAdminRepo(cycle_id='{}',client_id='{}',emp_id='{}',password_='{}'," \ "is_super_admin='{}')>".format(self.cycle_id, self.client_id, self.emp_id, self.password_, self.is_super_admin) def get_json(self): body = { "cycle_id": self.cycle_id, "client_id": self.client_id, "emp_id": self.emp_id, "password": self.password_, "is_super_admin": self.is_super_admin } return body
class Customer(STModel): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(NAME_LENGTH), index=True, nullable=False) contact = db.Column(db.String(CONTACT_LENGTH)) address = db.Column(db.String(ADDRESS_LENGTH)) sale_transactions = db.relationship('SaleTransaction', backref='customer', lazy='dynamic', cascade='save-update, merge, delete') @classmethod def check_exist(cls, name): return db.session.query(exists().where(Customer.name == name)).scalar() @classmethod def try_add(cls, name, contact=None, address=None): # no need to check exists in here because # the form has handled it and the model fields has unique=True new_cou = Customer(name=name, contact=contact, address=address) try: db.session.add(new_cou) db.session.commit() return True except Exception as e: cls.add_error(e) db.session.rollback() return False @classmethod def get_list(cls, page_num=DEFAULT_PAGE_NUMBER, list_per_page=DEFAULT_POSTS_PER_PAGE, include_header=True, order_by=None, **kwargs): q = Customer.query.with_entities(Customer.id, Customer.name, Customer.address, Customer.contact) q = paginate_query(q, page_num, list_per_page) if order_by: q = q.order_by(order_by) c_list = q.all() if include_header: c_list.insert(0, tuple(x['name'] for x in q.column_descriptions)) return c_list
class EmployeeDetailsRepo(Base): __tablename__ = 'employee_details_m' emp_id = db.Column(db.String(20), primary_key=True) client_id = db.Column(db.String(64), db.ForeignKey(ClientRepo.client_id), nullable=False) emp_name = db.Column(db.String(64), nullable=False) emp_email = db.Column(db.String(64), nullable=False) department_id = db.Column(db.Integer, db.ForeignKey( ClientDepartmentsDetailsRepo.department_id), nullable=False) role_id = db.Column(db.Integer, db.ForeignKey(UserRoleRepo.role_id), nullable=False) password = db.Column(db.Text, nullable=False) ParticipantsAssessmentStatus = relationship("ParticipantsAssessmentStatus", cascade="all,delete", backref="EmployeeDetailsRepo") IndividualScores = relationship("IndividualScores", cascade="all,delete", backref="EmployeeDetailsRepo") CompetancyScores = relationship("CompetancyScores", cascade="all,delete", backref="EmployeeDetailsRepo") ClientAdminRepo = relationship("ClientAdminRepo", cascade="all,delete", backref="EmployeeDetailsRepo") def __repr__(self): return "<EmployeeDetailsRepo(emp_id='{}',client_id='{}',emp_name='{}',emp_email='{}')>".format( self.emp_id, self.client_id, self.emp_name, self.emp_email) def get_json(self): body = { "emp_id": self.emp_id, "client_id": self.client_id, "emp_name": self.emp_name, "emp_email": self.emp_email, "department_id": self.department_id, "role_id": self.role_id } return body
class domain(db.Model): __tablename__ = 'domain' domainID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True) name = db.Column(db.String(30), nullable=False) # This function should return a printable representation of the domain object def __repr__(self): return '<domain: {}>'.format(self.name)
class topic(db.Model): __tablename__ = 'topic' topicID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True) name = db.Column(db.String(30), nullable=False) domainID = db.Column(db.Integer, db.ForeignKey('domain.domainID'), nullable=False) # This function should return a printable representation of the topic object def __repr__(self): return '<topic: {}>'.format(self.name)
class option(db.Model): __tablename__ = 'option' optionID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True) description = db.Column(db.String(255), nullable=False) correct = db.Column(db.SmallInteger, nullable=False) questionID = db.Column(db.Integer, db.ForeignKey('question.questionID'), nullable=False) # This function should return a printable representation of the option object def __repr__(self): return '<option: {}>'.format(self.description)
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(40), unique=True, nullable=False) password = db.Column(db.String(60), nullable=False) activated = db.Column(db.Boolean, default=False) sheets = db.relationship('Character', backref='owner', lazy=True) def get_token(self, expires=600): s = Serializer(app.config['SECRET_KEY'], expires) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_token(token): s = Serializer(app.config['SECRET_KEY']) try: user_id = s.loads(token)['user_id'] except Exception: return None return User.query.get(user_id)
class AutoComplete(db.Model): """Declare model for "auto_complete" database. +----------------+---------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------------+---------------+------+-----+---------+-------+ | starting_words | varchar(3000) | YES | | NULL | | | following_word | varchar(3000) | YES | | NULL | | | word_count | int(11) | YES | | NULL | | +----------------+---------------+------+-----+---------+-------+ Args: db (flask_sqlalchemy.model.DefaultMeta): base class of model """ starting_words = db.Column(db.String(3000)) following_word = db.Column(db.String(3000)) word_count = db.Column(db.Integer, unique=False, nullable=True, primary_key=True)
class user(db.Model): __tablename__ = 'user' userID = db.Column(db.Integer, nullable=False, primary_key=True) name = db.Column(db.String(255), nullable=False) # 28/03/2021 - create relationship between 'user' and 'user_test' testsTaken = db.relationship('user_test', backref='user', lazy='joined') # This function should return a printable representation of the user object def __repr__(self): return '<user: {}>'.format(self.name)
class Supplier(STModel): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(NAME_LENGTH), index=True, nullable=False) contact = db.Column(db.String(CONTACT_LENGTH)) address = db.Column(db.String(ADDRESS_LENGTH)) purchase_transactions = db.relationship( 'PurchaseTransaction', backref='supplier', lazy='dynamic', cascade='save-update, merge, delete') @classmethod def get_list(cls, page_num=DEFAULT_PAGE_NUMBER, list_per_page=DEFAULT_POSTS_PER_PAGE, include_header=True, order_by=None, **kwargs): q = Supplier.query.with_entities(Supplier.id, Supplier.name, Supplier.contact, Supplier.address) q = paginate_query(q, page_num, list_per_page) s_list = q.all() s_list.insert(0, tuple(x['name'] for x in q.column_descriptions)) return s_list @classmethod def try_add(cls, name, contact, address): new = Supplier(name=name, contact=contact, address=address) try: db.session.add(new) db.session.commit() return True except Exception as e: cls.add_error(e) db.session.rollback() return False
class Module(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) description = db.Column(db.String) owner_id = db.Column(db.Integer) img = db.Column(db.String(80)) def __init__(self, name, description, owner_id, img): self.name = name self.description = description self.owner_id = owner_id self.img = img def serialize(self): return { "id": self.id, "name": self.name, "description": self.description, "owner_id": self.owner_id, "imd": self.img } def add_a_module_by_enity(module): db.session.add(module) db.session.commit() return module.serialize() def update_a_module_by_enity(module_new): module_old = Module.query.filter_by(id=module_new.id).first() if module_old is not None: module_old.name = module_new.name module_old.description = module_new.description db.session.commit() return True else: return False
class TransactionMedium(STModel): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(NAME_LENGTH), index=True, nullable=False, unique=True) sale_transactions = db.relationship('SaleTransaction', backref='transaction_medium', lazy='dynamic') @classmethod def check_exist(cls, name): return db.session.query( exists().where(TransactionMedium.name == name)).scalar() @classmethod def try_add(cls, name): new_tm = TransactionMedium(name=name) try: db.session.add(new_tm) db.session.commit() return True except Exception as e: cls.add_error(e) db.session.rollback() return False @classmethod def get_list(cls, page_num=DEFAULT_PAGE_NUMBER, list_per_page=DEFAULT_POSTS_PER_PAGE, include_header=True, order_by=None, **kwargs): q = TransactionMedium.query.with_entities(TransactionMedium.id, TransactionMedium.name) q = paginate_query(q, page_num, list_per_page) if order_by: q = q.order_by(order_by) tm_list = q.all() if include_header: tm_list.insert(0, tuple(x['name'] for x in q.column_descriptions)) return tm_list
class question(db.Model): __tablename__ = 'question' questionID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True) description = db.Column(db.String(600), nullable=False) testQuestions = db.relationship('test_question', backref='question', lazy='joined') # 16/03/2021 - Create relationship between question and option classes, in order to load the multiple options related to a single question # A relationship will allow for both questions and options to be pulled from the database together in a single query statement options = db.relationship('option', backref='question', lazy='joined') # 24/03/2021 - Create a relationship between question and answer classes, in order to load the option the user selected to answer the current question answer = db.relationship('answer', backref='question', lazy='joined') # This function should be return a printable representation of the question object def __repr__(self): return '<question: {}>'.format(self.description)
class UserRoleRepo(Base): __tablename__ = 'user_roles_m' role_id = db.Column(db.Integer, primary_key=True, autoincrement=True) role_type = db.Column(db.String(64), nullable=False) EmployeeDetailsRepo = relationship("EmployeeDetailsRepo", cascade="all,delete", backref="UserRoleRepo", lazy='joined') def __repr__(self): return "<UserRoleRepo(role_id='{}',role_type='{}')>".format( self.role_id, self.role_type) def get_json(self): body = {"role_id": self.role_id, "role_type": self.role_type} return body
class AssessmentCompletionStatusRepo(Base): __tablename__ = 'assessment_completion_status_m' status_id = db.Column(db.Integer, primary_key=True, autoincrement=True) status_type = db.Column(db.String(20), nullable=False) ParticipantsAssessmentStatus = relationship( "ParticipantsAssessmentStatus", cascade="all,delete", backref="AssessmentCompletionStatusRepo") def __repr__(self): return "<AssessmentCompletionStatusRepo(status_id='{}',status_type='{}')>".format( self.status_id, self.status_type) def get_json(self): body = {"status_id": self.status_id, "status_type": self.status_type} return body
class FeedBackLevelRepo(Base): __tablename__ = 'feedback_level_m' level_id = db.Column(db.Integer, primary_key=True, autoincrement=True) level_type = db.Column(db.String(20), nullable=False) FeedBackStatements = relationship("FeedBackStatements", cascade="all,delete", backref="FeedBackLevelRepo", lazy='joined') def __repr__(self): return "<FeedBackLevelRepo(level_id='{}',level_type='{}')>".format( self.level_id, self.level_type) def get_json(self): body = {"level_id": self.level_id, "level_type": self.level_type} return body
class Course(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) description = db.Column(db.String) module = db.Column(db.Integer) def __init__(self, name, description, module): self.name = name self.description = description self.module = module def serialize(self): return { "id": self.id, "name": self.name, "description": self.description, "module": self.module }