class Todo(db.Model): id = db.Column(db.Integer(), primary_key=True) task = db.Column(db.Text(), nullable=False) tasker_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return [self.task, self.tasker_id]
class Message(db.Model): id = db.Column(db.Integer, primary_key=True) sender_id = db.Column(db.Integer, db.ForeignKey('user.id')) recipient_id = db.Column(db.Integer, db.ForeignKey('user.id')) body = db.Column(db.String(240)) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) def __repr__(self): return '<Message {}>'.format(self.body)
class Notification(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128), index=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) timestamp = db.Column(db.Float, index=True, default=time) payload_json = db.Column(db.Text) def get_data(self): return json.loads(str(self.payload_json))
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(64), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) tasks = db.relationship('Todo', backref='tasker', lazy=True) def __str__(self): return [self.username, self.email]
class Task(db.Model): __tablename__ = 'tasks' id = db.Column(db.Integer, primary_key=True) description = db.Column(db.String(140), nullable=False) completed = db.Column(db.Boolean, default=False) def __init__(self, description, completed=False): self.description = description self.completed = completed
class Institutions(db.Model): __tablename__ = "institutions" id = db.Column(db.Integer, primary_key=True) district = db.Column(db.Integer) institution = db.Column(db.String(200), nullable=False) def __repr__(self): return '{"id":{0}, "institution":{1}}'.format(self.id, self.institution) @classmethod def get_all_institutions(classname): institutions = Institutions.query.all() institutions_json = [ institution.serialize() for institution in institutions ] return institutions_json @classmethod def get_institution_from(classname, id): institution = classname.query.get(id) return institution @classmethod def delete_institution_from(classname, id): institution = classname.get_institution_from(id) if institution is None: return None db.session.delete(institution) db.session.commit() return institution @classmethod def submit_institution_from_json(classname, json_institution): institution = classname(institution=json_institution['institution'], district=json_institution["district"]) db.session.add(institution) db.session.commit() return institution #todo:json encoding needed def serialize(self): json_institution = { 'id': self.id, 'institution': self.institution, } return json_institution @staticmethod def validate_institution(institution): if ('institution' in institution): return True else: return False
class Qualifications(db.Model): __tablename__ = "qualifications" id = db.Column(db.Integer, primary_key=True, autoincrement=True) qualification = db.Column(db.String(200), nullable=False) def __repr__(self): return '{"id":{0}, "qualification":{1}}'.format( self.id, self.qualification) @classmethod def get_all_qualifications(classname): qualifications = Qualifications.query.all() qualifications_json = [ qualification.serialize() for qualification in qualifications ] return qualifications_json @classmethod def get_qualification_from(classname, id): qualification = classname.query.get(id) return qualification @classmethod def delete_qualification_from(classname, id): qualification = classname.get_qualification_from(id) if qualification is None: return None db.session.delete(qualification) db.session.commit() return qualification @classmethod def submit_qualification_from_json(classname, json_qualification): qualification = classname( qualification=json_qualification['qualification']) db.session.add(qualification) db.session.commit() return qualification #todo:json encoding needed def serialize(self): json_qualification = { 'id': self.id, 'name': self.qualification, } return json_qualification @staticmethod def validate_qualification(qualification): if ('qualification' in qualification): return True else: return False
class Patient(db.Model): ssn_id = db.Column(db.String(50), unique=True) patient_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) age = db.Column(db.Integer) # Change to date type admission_date = db.Column(db.Integer) bed_type = db.Column(db.String(15)) address = db.Column(db.String(200)) city = db.Column(db.String(50)) state = db.Column(db.String(50)) status = db.Column(db.String(15)) med_list = db.relationship('Track_Medicines', backref='patient', lazy=True)
class Districts(db.Model): __tablename__ = "districts" id = db.Column(db.Integer, primary_key=True) district = db.Column(db.String(200), nullable=False) state = db.Column(db.Integer) def __repr__(self): return '{"id":{0}, "district":{1}}'.format(self.id, self.district) @classmethod def get_all_districts(classname): districts = Districts.query.all() districts_json = [district.serialize() for district in districts] return districts_json @classmethod def get_district_from(classname, id): district = classname.query.get(id) return district @classmethod def delete_district_from(classname, id): district = classname.get_district_from(id) if district is None: return None db.session.delete(district) db.session.commit() return district @classmethod def submit_district_from_json(classname, json_district): district = classname(district=json_district['district'], state=json_district.get("state", 0)) db.session.add(district) db.session.commit() return district #todo:json encoding needed def serialize(self): json_district = { 'id': self.id, 'name': self.district, } return json_district @staticmethod def validate_district(district): if ('district' in district): return True else: return False
class Track_Medicines(db.Model): id = db.Column(db.Integer, primary_key=True) patient_id = db.Column(db.Integer, db.ForeignKey('patient.patient_id')) med_id = db.Column(db.Integer, db.ForeignKey('medicine__master.med_id')) quantity_issued = db.Column(db.Integer) # patient_1 = Patient(ssn_id=12, name='asd', age=32, admission_date=12, bed_type='asd', address='asd', city='asd', state='asd', status='asd') # med_1 = Medicine_Master(med_name='sad', quantity=12, rate=21) # track_1 = Track_Medicines(patient_id=patient_1.patient_id, med_id=med_1.med_id, quantity_issued=213) # Patient.query.get(1).med_list[0].medicine.med_name
class Towns(db.Model): __tablename__ = "towns" id = db.Column(db.Integer, primary_key=True) district = db.Column(db.Integer) town = db.Column(db.String(200), nullable=False) def __repr__(self): return '{"id":{0}, "town":{1}}'.format(self.id, self.town) @classmethod def get_all_towns(classname): towns = Towns.query.all() towns_json = [town.serialize() for town in towns] return towns_json @classmethod def get_town_from(classname, id): town = classname.query.get(id) return town @classmethod def delete_town_from(classname, id): town = classname.get_town_from(id) if town is None: return None db.session.delete(town) db.session.commit() return town @classmethod def submit_town_from_json(classname, json_town): town = classname(town=json_town['town'], district=json_town.get("district", 0)) db.session.add(town) db.session.commit() return town #todo:json encoding needed def serialize(self): json_town = { 'id' : self.id , 'town' : self.town, } return json_town @staticmethod def validate_town(town): if ('town' in town): return True else: return False
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64)) email = db.Column(db.String(128), unique=True) pw_hash = db.Column(db.String(128)) def __init__(self, name, email, password): self.name = name self.email = email self.pw_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.pw_hash, password)
class Subjects(db.Model): __tablename__ = "subjects" id = db.Column(db.Integer, primary_key=True, autoincrement=True) subject = db.Column(db.String(200), nullable=False) def __repr__(self): return '{"id":{0}, "subject":{1}}'.format(self.id, self.subject) @classmethod def get_all_subjects(classname): subjects = Subjects.query.all() subjects_json = [subject.serialize() for subject in subjects] return subjects_json @classmethod def get_subject_from(classname, id): subject = classname.query.get(id) return subject @classmethod def delete_subject_from(classname, id): subject = classname.get_subject_from(id) if subject is None: return None db.session.delete(subject) db.session.commit() return subject @classmethod def submit_subject_from_json(classname, json_subject): subject = classname(subject=json_subject['subject']) db.session.add(subject) db.session.commit() return subject #todo:json encoding needed def serialize(self): json_subject = { 'id': self.id, 'name': self.subject, } return json_subject @staticmethod def validate_subject(subject): if ('subject' in subject): return True else: return False
class States(db.Model): __tablename__ = "states" id = db.Column(db.Integer, primary_key=True) state = db.Column(db.String(200), nullable=False) def __repr__(self): return '{"id":{0}, "state":{1}}'.format(self.id, self.state) @classmethod def get_all_states(classname): states = States.query.all() states_json = [state.serialize() for state in states] return states_json @classmethod def get_state_from(classname, id): state = classname.query.get(id) return state @classmethod def delete_state_from(classname, id): state = classname.get_state_from(id) if state is None: return None db.session.delete(state) db.session.commit() return state @classmethod def submit_state_from_json(classname, json_state): state = classname(state=json_state['state']) db.session.add(state) db.session.commit() return state #todo:json encoding needed def serialize(self): json_state = { 'id': self.id, 'state': self.state, } return json_state @staticmethod def validate_state(state): if ('state' in state): return True else: return False
class Resume(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) category = db.Column(db.String(40), index=True) year = db.Column(db.String(30), index=True) title = db.Column(db.String(300), index=True) sub_title = db.Column(db.String(300), index=True) body = db.Column(db.String(800)) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) def __repr__(self): return "{0.user_id} - {0.body}".format(self)
class User(db.Model, UserMixin): id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True) app = db.Column(db.String(20)) env = db.Column(db.String(20)) machine = db.Column(db.String(20)) ip = db.Column(db.String(20)) hostuser = db.Column(db.String(20)) hostpass = db.Column(db.String(20)) weburl = db.Column(db.String(70)) webproxyurl = db.Column(db.String(70)) webuser = db.Column(db.String(20)) webpass = db.Column(db.String(20)) dbhost = db.Column(db.String(20)) dbip = db.Column(db.String(20)) dbuser = db.Column(db.String(20)) dbpass = db.Column(db.String(20)) dbport = db.Column(db.String(20)) dbsid = db.Column(db.String(20)) certstorepath = db.Column(db.String(80)) certtype = db.Column(db.String(20)) certstorepass = db.Column(db.String(20)) certkeypass = db.Column(db.String(20)) dateupdated = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) updatedby = db.Column(db.String(20)) other_details = db.Column(db.String(500)) def __repr__(self): return f"User('{self.id}', '{self.app}', '{self.env}','{self.machine}', '{self.ip}', '{self.hostuser}', '{self.hostpass}','{self.weburl}','{self.webproxyurl}', '{self.webuser}','{self.webpass}','{self.dbhost}','{self.dbip}','{self.dbuser}','{self.dbpass}','{self.dbport}','{self.dbsid}','{self.certstorepath}','{self.certtype}','{self.certstorepass}','{self.certkeypass}','{self.dateupdated}','{self.updatedby}','{self.other_details}')"
class Seekerdetails(db.Model): __tablename__ = "seekerdetails" id = db.Column(db.Integer, primary_key=True) contactnumber = db.Column(db.Integer) experience = db.Column(db.Integer) currentpack = db.Column(db.Integer) expectedpack = db.Column(db.Integer) qualification = db.Column(db.Integer, db.ForeignKey('qualifications.id')) subject = db.Column(db.Integer, db.ForeignKey('subjects.id')) experiences = db.Column(db.String(2000)) address = db.Column(db.String(2000)) district = db.Column(db.Integer, db.ForeignKey('districts.id')) state = db.Column(db.Integer, db.ForeignKey('states.id')) medium = db.Column(db.Integer) user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) def serialize(self): json_user = { "id": self.id, "Contact Number": self.contactnumber, #"registered_on": str(self.registered_on), "Experience": self.experience, "Current Package": self.currentpack, "Qualification": self.qualification, # "Experience History": self.experiences, #"Address": self.address, "District": self.district, "State": self.state, "Medium": self.medium, } return json_user
class Questions(db.Model): __tablename__ = "questions" id = db.Column(db.Integer, primary_key=True) module_id = db.Column(db.Integer, nullable=False) question_type = db.Column(db.Integer, nullable=False) creator_id = db.Column(db.Integer, nullable=False) is_active = db.Column(db.Boolean, default=True) question = db.Column(db.String(2000), nullable=False) options = db.relationship('Options', backref='enquiry', lazy=True) insert_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) update_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) def __repr__(self): return '{"id":{0}, "question":{1}}'.format(self.id, self.question) @classmethod def get_all_questions(classname): questions_list = Questions.query.all() questions = [question.serialize() for question in questions_list] return questions @classmethod def get_question_from_id(classname, id): question = classname.query.get(id) return question @classmethod def delete_question_from_id(classname, id): question = classname.get_question_from_id(id) if question is None: return None #first delete the options #TODO: currently the deletions of options and question is not atmoic options = Options.delete_options_from_qid(id) db.session.delete(question) db.session.commit() return question @classmethod def submit_question_from_json(classname, json_question): question = classname(question=json_question['question']) question.module_id = int(json_question['module_id']) question.creator_id = int(json_question['creator_id']) question.question_type = int(json_question['question_type']) db.session.add(question) db.session.commit() #todo: make options and question creation atomic Options.submit_options_from_json(json_question['options'], question.id) return question #todo:json encoding needed def serialize(self): json_question = { 'id': self.id, 'module_id': self.module_id, 'question_type': self.question_type, 'creator_id': self.creator_id, 'is_active': self.is_active, 'question': self.question, 'insert_date': str(self.insert_date), 'update_date': str(self.update_date), 'options': Options.serialize_all(self.options) } return json_question @staticmethod def validate_question(question): if ('question' in question and 'module_id' in question and 'question_type' in question): return True else: return False
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(140), nullable=False, unique=True) email = db.Column(db.String(140), nullable=False, unique=True) password = db.Column(db.String(80), nullable=False) image = db.Column(db.String(120), default='default.jpg', nullable=False) resume = db.Column(db.String(120), default='default.pdf', nullable=False) # personal details name = db.Column(db.String(40)) mobile = db.Column(db.String(14)) phone = db.Column(db.String(14)) dob = db.Column(db.String(20)) address = db.Column(db.String(200)) hobbies = db.Column(db.String(100)) country = db.Column(db.String(30)) city = db.Column(db.String(30)) # for Messages messages_sent = db.relationship('Message', foreign_keys='Message.sender_id', backref='author', lazy='dynamic') messages_received = db.relationship('Message', foreign_keys='Message.recipient_id', backref='recipient', lazy='dynamic') last_message_read_time = db.Column(db.DateTime) notifications = db.relationship('Notification', backref='user', lazy='dynamic') # for resume resume_details = db.relationship('Resume', backref='resume_details', lazy='dynamic') # add notification def add_notification(self, name, data): self.notifications.filter_by(name=name).delete() n = Notification(name=name, payload_json=json.dumps(data), user=self) db.session.add(n) return n # for getting new Messages def new_messages(self): last_read_time = self.last_message_read_time or datetime(1900, 1, 1) return Message.query.filter_by(recipient=self).filter( Message.timestamp > last_read_time).count() # for password reset def get_reset_token(self, expires_in=600): return jwt.encode( { 'reset_password': self.id, 'exp': time() + expires_in }, app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8') @staticmethod def verify_reset_token(token): try: print(token) id = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password'] except: return None return User.query.get(id) def __repr__(self): return "{0.username} - {0.email}".format(self)
class userstore(db.Model): time_stamp = db.Column("time_stamp", db.DateTime, primary_key=True) login = db.Column(db.String(100)) password = db.Column(db.String(100)) user_type = db.Column(db.String(100))
class Modules(db.Model): __tablename__ = "modules" id = db.Column(db.Integer, primary_key=True) module = db.Column(db.String(50), nullable=False) parent_module_id = db.Column(db.Integer, nullable=True) description = db.Column(db.String(2000), nullable=True) creator_id = db.Column(db.Integer, nullable=False) is_active = db.Column(db.Boolean, default=True) insert_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) update_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) def __repr__(self): return '{"id":{0}, "module":{1}, "parent":{2}}, "creator_id": {3}'.format( self.id, self.module, self.parent_module_id, self.creator_id) @classmethod def get_all_modules(classname): modules_list = Modules.query.all() modules = [module.brief() for module in modules_list] return modules @classmethod def get_modules_latest_count(classname, _count, id=None): if id == None: modules_list = Modules.query.order_by( classname.insert_date.desc()).limit(_count) else: modules_list = Modules.query.filter_by(creator_id=id).order_by( classname.insert_date.desc()).limit(_count) modules = [module.brief() for module in modules_list] return modules @classmethod def get_module_from_id(classname, id): module = classname.query.get(id) return module.serialize() @classmethod def get_module_from_creator_id(classname, id): modules_list = classname.query.filter_by(creator_id=id) modules = [module.brief() for module in modules_list] return modules @classmethod def delete_module_from_id(classname, id): module = classname.get_module_from_id(id) if module is None: return None db.session.delete(module) db.session.commit() return module @classmethod def submit_module_from_json(classname, json_module): module = classname(module=json_module['module'], parent_module_id=json_module['parent_module_id'], description=json_module['description'], creator_id=json_module['creator_id'], is_active=json_module['is_active']) db.session.add(module) db.session.commit() return module #todo:json encoding needed def serialize(self): json_module = { 'id': self.id, 'module': self.module, 'parent_module_id': self.parent_module_id, 'description': self.description, 'creator_id': self.creator_id, 'is_active': self.is_active, 'insert_date': str(self.insert_date), 'update_date': str(self.update_date) } return json_module def brief(self): json_module = { 'id': self.id, 'module': self.module, 'description': self.description } return json_module @staticmethod def validate_module(module): if ('module' in module): return True else: return False
class Exams(db.Model): __tablename__ = "exams" id = db.Column(db.Integer, primary_key=True) exam = db.Column(db.String(50), nullable=False) parent_exam_id = db.Column(db.Integer, nullable=True) description = db.Column(db.String(2000), nullable=True) duration_sec = db.Column(db.Integer, nullable=False) creator_id = db.Column(db.Integer, nullable=False) is_active = db.Column(db.Boolean, default=True) insert_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) update_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) def __repr__(self): return '{"id":{0}, "exam":{1}, "parent":{2}}, "creator_id": {3}'.format(self.id, self.exam, self.parent_exam_id, self.creator_id) @classmethod def get_all_exams(classname): exams_list = Exams.query.all() exams = [exam.brief() for exam in exams_list] return exams @classmethod def get_exams_latest_count(classname, _count, id=None): if id == None: exams_list = Exams.query.order_by(classname.insert_date.desc()).limit(_count) else: exams_list = Exams.query.filter_by(creator_id=id).order_by(classname.insert_date.desc()).limit(_count) exams = [exam.brief() for exam in exams_list] return exams @classmethod def get_exam_from_id(classname, id): exam = classname.query.get(id) return exam.serialize() @classmethod def get_exam_from_creator_id(classname, id): exams_list = classname.query.filter_by(creator_id=id) exams = [exam.brief() for exam in exams_list] return exams @classmethod def delete_exam_from_id(classname, id): exam = classname.get_exam_from_id(id) if exam is None: return None db.session.delete(exam) db.session.commit() return exam @classmethod def submit_exam_from_json(classname, json_exam): exam = classname(exam=json_exam['exam'], parent_exam_id=json_exam['parent_exam_id'], description=json_exam['description'], duration_sec=json_exam['duration_sec'], creator_id=json_exam['creator_id'], is_active=json_exam['is_active']) db.session.add(exam) db.session.commit() return exam #todo:json encoding needed def serialize(self): json_exam = { 'id' : self.id , 'exam' : self.exam, 'parent_exam_id' : self.parent_exam_id, 'description': self.description, 'duration_sec': self.duration_sec, 'creator_id': self.creator_id, 'is_active': self.is_active, 'insert_date': str(self.insert_date), 'update_date': str(self.update_date) } return json_exam def brief(self): json_exam = { 'id' : self.id , 'exam' : self.exam, 'description': self.description } return json_exam @staticmethod def validate_exam(exam): if ('exam' in exam): return True else: return False
class Users(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), nullable=False) firstname = db.Column(db.String(80), nullable=True) lastname = db.Column(db.String(80), nullable=True) email = db.Column(db.String(80), nullable=False) password = db.Column(db.String(80), nullable=False) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.now()) isrecruiter = db.Column(db.Boolean, nullable=False, default=False) isactive = db.Column(db.Boolean, nullable=False, default=False) details = db.relationship('Seekerdetails', backref='enquiry', lazy=True) def __repr__(self): return '{"username": {0}, "email": {1}, "recruiter": {2} }'.format(self.username, self.email, self.isrecruiter) def fullname(self): return "{} {}".format(self.firstname, self.lastname) @classmethod def username_password_match(classname, _email, _password): print(_email, _password) user = classname.query.filter_by(email=_email).first() if user and bcrypt.check_password_hash(user.password, _password): print("exists") return user else: print("absent") return None @classmethod def add_user(classname, _user): try: pw_hash = bcrypt.generate_password_hash(_user.password) _user.password = pw_hash db.session.add(_user) db.session.commit() except Exception as e: return e return classname.get_user_by_username(_user.username) @classmethod def get_all_users(classname): return [user.serialize() for user in classname.query.all()] @classmethod def get_user_by_username(classname, _username): try: user_object = classname.query.filter_by(username=_username).first() if(user_object == None): return user_object else: return user_object.serialize() except: return False @classmethod def get_users_from_text(classname, text): query = """select id, Users.firstname, Users.lastname from Users where Users.firstname like "%{}%" or Users.lastname like "%{}%" or Users.username like "%{}%" """.format(text, text, text) result = db.engine.execute(query) list_result =[] for user in result: user_dict = {} user_dict['id'] = user[0] user_dict['label'] = "{} {}".format(user[1], user[2]) list_result.append(user_dict) return list_result @classmethod def get_user_by_email(classname, _email): try: user_object = classname.query.filter_by(email=_email).first() if(user_object == None): return user_object else: return user_object.serialize() except: return False @classmethod def get_user_by(classname, id): user_object = classname.query.get(id) if(user_object == None): return None else: return user_object @classmethod def delete_user_by_username(classname, _username): try: classname.query.filter_by(username=_username).delete() db.session.commit() except: return False return True @classmethod def update_user_by_username(classname, _username, _user): try: user_to_update = classname.query.filter_by(username=_username).first() user_to_update.email = _user.email user_to_update.password = _user.password db.session.commit() except: return False return classname.get_user_by_username(_user.username) @staticmethod def validate_user(user): if ("username" in user and "email" in user and "password" in user): return True else: return False def encode_auth_token(self): """ Generates the Auth Token :return: string """ try: header = { "alg": "HS256", "typ": "JWT" } # Max value = timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999) payload = { "exp": datetime.utcnow() + timedelta(days=2, hours=0, minutes=0, seconds=0, microseconds=0), "iat": datetime.utcnow(), "sub": self.id, "name": self.username } return encode(payload, self.username, headers=header) #return "hshhdhdsjlhlfdjh" except Exception as e: return e @classmethod def get_users_by_filter(classname, filter): query = "select * from Users inner join seekerdetails on Users.id = Seekerdetails.user where " for key, value in filter.items(): query = "{} Seekerdetails.{} = {}".format(query, key, value) print(query) result = db.engine.execute(query) list_result =[] for job in result: job_object = dict(zip(result.keys(), job)) list_result.append(User.serialize_dict(job_object)) return list_result def serialize(self): json_user = { "id": self.id, "Username": self.username, "Email": self.email, #"registered_on": str(self.registered_on), "Recruiter": self.isrecruiter, "Fullname": self.fullname(), "details" : [detail.serialize() for detail in self.details] } return json_user ############################################################################################ #All the functions to retrieve seeker details and update them ############################################################################################ def update_user(self, details): db.session.add(self) db.session.add(details) db.session.commit()
class Options(db.Model): __tablename__ = "options" id = db.Column(db.Integer, primary_key=True) option = db.Column(db.String(200), nullable=False) question_id = db.Column(db.Integer, db.ForeignKey('questions.id'), nullable=False) is_correct_option = db.Column(db.Integer, nullable=False, default=0) insert_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) update_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) def __rept__(self): return "'id': {0}, 'option': {1}, 'question_id': {2}".format( self.id, self.option, self.question_id) @classmethod def get_all_options(classname): return [option.serialize() for option in classname.query.all()] @classmethod def get_options_from_qid(classname, question_id): options = classname.query.filter_by(question_id=question_id) return options @classmethod def submit_options_from_json(classname, json_options, question_id): for json_option in json_options: option = Options( option=json_option['option'], question_id=question_id, is_correct_option=json_option['is_correct_option']) db.session.add(option) db.session.commit() @classmethod def delete_options_from_qid(classname, question_id): options = classname.get_options_from_qid(question_id) if options is None: return None for option in options: db.session.delete(option) db.session.commit() return options def serialize(self): json_option = { 'id': self.id, 'option': self.option, 'question_id': self.question_id, 'is_correct_option': self.is_correct_option, 'insert_date': str(self.insert_date), 'update_date': str(self.update_date) } return json_option #todo:json encoding needed @staticmethod def serialize_all(options): return [option.serialize() for option in options] @staticmethod def validate_option(option): if ('id' in option and 'option' in option and 'question_id' in option and 'is_correct_option' in option): return True else: return False
class Users(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), nullable=False) email = db.Column(db.String(80), nullable=False) password = db.Column(db.String(80), nullable=False) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.now()) admin = db.Column(db.Boolean, nullable=False, default=False) def __repr__(self): return "{'id': {0}, 'username': {1}, 'email': {2}, 'creation': {3}, 'admin': {4} }".format( self.id, self.username, self.email, self.registered_on, self.admin) @classmethod def username_password_match(classname, _email, _password): user = classname.query.filter_by(email=_email).first() #TODO: Encrypt password if user and (user.password == _password): return user else: return None @classmethod def add_user(classname, _user): try: db.session.add(_user) db.session.commit() except Exception as e: return e return classname.get_user_by_username(_user.username, False) @classmethod def get_all_users(classname): return [user.serialize() for user in classname.query.all()] @classmethod def get_user_by_username(classname, _username, _with_password): try: user_object = classname.query.filter_by(username=_username).first() if (user_object == None): return user_object else: if (_with_password): return user_object.serialize() else: return user_object.get_user() except: return False @classmethod def get_user_by_email(classname, _email): try: user_object = classname.query.filter_by(email=_email).first() if (user_object == None): return user_object else: return user_object.serialize() except: return False @classmethod def delete_user_by_username(classname, _username): try: classname.query.filter_by(username=_username).delete() db.session.commit() except: return False return True @classmethod def update_user_by_username(classname, _username, _user): try: user_to_update = classname.query.filter_by( username=_username).first() user_to_update.email = _user.email user_to_update.password = _user.password db.session.commit() except: return False return classname.get_user_by_username(_user.username, False) @staticmethod def validate_user(user): if ("username" in user and "email" in user and "password" in user): return True else: return False def get_user(self): json_user = { "id": self.id, "username": self.username, "email": self.email, "registered_on": str(self.registered_on), "admin": self.admin } return json_user def encode_auth_token(self): """ Generates the Auth Token :return: string """ try: header = {"alg": "HS256", "typ": "JWT"} # Max value = timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999) payload = { "exp": datetime.utcnow() + timedelta( days=2, hours=0, minutes=0, seconds=0, microseconds=0), "iat": datetime.utcnow(), "sub": self.id, "name": self.username } return encode(payload, self.username, headers=header) except Exception as e: return e def serialize(self): json_user = { "id": self.id, "username": self.username, "email": self.email, "password": self.password, "registered_on": str(self.registered_on), "admin": self.admin } return json_user
class Jobs(db.Model): __tablename__ = "jobs" id = db.Column(db.Integer, primary_key=True) subject = db.Column(db.Integer, db.ForeignKey('subjects.id')) jobdetails = db.Column(db.String(2000), default="") minexperience = db.Column(db.Integer, default=0) maxexperience = db.Column(db.Integer, default=0) telephone = db.Column(db.Integer, default=0) institution = db.Column(db.String(80), default="") description = db.Column(db.String(80), default="") recruiter = db.Column(db.Integer, db.ForeignKey('users.id')) qualification = db.Column(db.Integer, db.ForeignKey('qualifications.id')) state = db.Column(db.Integer, db.ForeignKey('states.id')) district = db.Column(db.Integer, db.ForeignKey('districts.id')) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.now()) closed_on = db.Column(db.DateTime) isactive = db.Column(db.Boolean, nullable=False, default=True) @classmethod def add_job(classname, _user): pass @classmethod def submit_job_from_json(classname, json_job): job = classname() if not json_job.get("subject", None) is None: job.subject = json_job.get("subject", None) if not json_job.get("jobdetails", None) is None: job.jobdetails = json_job.get("jobdetails", None) if not json_job.get("minexperience", None) is None: job.minexperience = json_job.get("minexperience", None) if not json_job.get("maxexperience", None) is None: job.maxexperience = json_job.get("maxexperience", None) if not json_job.get("telephone", None) is None: job.telephone = json_job.get("telephone", None) if not json_job.get("institution", None) is None: job.institution = json_job.get("institution", None) if not json_job.get("submitter", None) is None: user = users.Users.get_user_by_username(json_job.get("submitter", None)) if not user is None: print(user) job.recruiter = 1 if not json_job.get("district", None) is None: job.district = json_job.get("district", None) if not json_job.get("state", None) is None: job.state = json_job.get("state", None) if not json_job.get("qualification", None) is None: job.qualification = json_job.get("qualification", None) if not json_job.get("description", None) is None: job.description = json_job.get("description", None) db.session.add(job) db.session.commit() return job @classmethod def get_jobs_by_filter(classname, filter): query = "select * from jobs where " for key, value in filter.items(): query = "{} {} = {}".format(query, key, value) print(query) result = db.engine.execute(query) list_result =[] for job in result: job_object = dict(zip(result.keys(), job)) list_result.append(Jobs.serialize_dict(job_object)) return list_result def serialize(self): json_job = { "Id": self.id, "Title": self.description, #"Recruiter": users.Users.get_user_by(self.recruiter).email, "Minimum Qualification Needed": qualifications.Qualifications.get_qualification_from(self.qualification).qualification, "District": districts.Districts.get_district_from(self.district).district, "State": states.States.get_state_from(self.state).state, "School": self.institution, "Minimum years of Experience": self.minexperience, "Job Description": self.jobdetails, "Opened on":self.registered_on.strftime("%d-%B") } return json_job @classmethod def serialize_dict(classname, job_dict): json_job = { "Id": job_dict['id'], "Title": job_dict['description'], #"Recruiter": users.Users.get_user_by(self.recruiter).email, "Minimum Qualification Needed": qualifications.Qualifications.get_qualification_from(job_dict['qualification']).qualification, "District": districts.Districts.get_district_from(job_dict['district']).district, "State": states.States.get_state_from(job_dict['state']).state, "School": job_dict['institution'], "Minimum years of Experience": job_dict['minexperience'], "Job Description": job_dict['jobdetails'], "Opened on":job_dict['registered_on'] } return json_job
class Medicine_Master(db.Model): med_id = db.Column(db.Integer, primary_key=True) med_name = db.Column(db.String(50), unique=True) quantity = db.Column(db.Integer) rate = db.Column(db.Integer) patient = db.relationship('Track_Medicines', backref='medicine', lazy=True)