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)
