class FollowUpSummary(db.Model):
__tablename__ = 'follow_up_summary'
id = db.Column(db.Integer, primary_key=True)
program_id = db.Column(db.Integer,
db.ForeignKey('academic_programs.id'))
post_grad_employment_rate = db.Column(db.Float())
survey_year = db.Column(db.Integer())
class Calendar(db.Model):
"""Model for the calendar table"""
__tablename__ = 'Calendar'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(50), nullable=False)
facility = db.Column(db.String(50))
integrator = db.Column(db.String(50))
totalTime = db.Column(db.Integer())
startDate = db.Column(db.DateTime(), nullable=False)
private = db.Column(db.Boolean())
title = db.Column(db.String(50))
requestId = db.Column(db.Integer())
rangeId = db.Column(db.Integer())
beam = db.Column(db.Boolean())
energy = db.Column(db.Float())
def create_entry(self):
result = ""
try:
db.session.add(self)
db.session.commit()
result = {'success': True}
except Exception as e:
print(e)
result = {
'error': "Unable to create calendar entry",
'success': False
}
return result
def __repr__(self):
return "<Calendar(username=%s)>" % (self.username)
class Price(SpecialBase):
_tablename_ = "price"
value = db.Column(db.Float(), nullable=False)
description = db.Column(db.String(40), nullable=True)
availability = db.Column(db.String(30), nullable=False)
def __repr__(self):
return f"Price('{self.name}': '{self.value}', '{self.availability}')"
class SeasonalD(db.Model):
__tablename__ = "seasonalds"
id = db.Column(db.Integer, primary_key=True)
user_ids = db.relationship("User", backref="seasonalds", lazy=True)
seasonald_title = db.Column(db.String())
seasonald_offer = db.Column(db.Float())
def __repr__(self):
return f"<Artist {self.seasonald_title}>"
class Schedule(db.Model):
__tablename__ = 'schedule'
schedule_id = db.Column(db.Integer, primary_key=True)
menu_data_dump = db.Column(db.NVARCHAR)
chef_id = db.Column(db.String(255))
merchant_id = db.Column(db.String)
amount = db.Column(db.Float(10))
total_amount = db.Column(db.Float(10))
date = db.Column(db.DateTime)
def __init__(self, schedule_id, menu_data_dump, chef_id, merchant_id,
amount, total_amount, date):
self.schedule_id = schedule_id
self.menu_data_dump = menu_data_dump
self.chef_id = chef_id
self.merchant_id = merchant_id
self.amount = amount
self.total_amount = total_amount
self.date = date
class Order(db.Model):
order_id = db.Column(db.Integer, primary_key=True)
menu_data_dump = db.Column(db.String)
chef_id = db.Column(db.Integer, db.ForeignKey('schedule.chef_id'))
merchant_id = db.Column(db.String, db.ForeignKey('schedule.merchant_id'))
amount = db.Column(db.Float(10))
total_amount = db.Column(db.Float(10))
is_paid = db.Column(db.Boolean)
is_delivered = db.Column(db.Boolean)
def __init__(self, order_id, menu_data_dump, chef_id, merchant_id, amount,
total_amount, is_paid, is_delivered):
self.order_id = order_id
self.menu_data_dump = menu_data_dump
self.chef_id = chef_id
self.merchant_id = merchant_id
self.amount = amount
self.total_amount = total_amount
self.is_paid = is_paid
self.is_delivered = is_delivered
class Prediction(db.Model):
__tablename__ = 'predictions'
id = db.Column(db.Integer, primary_key=True)
currency = db.Column(db.String(80), nullable=False)
date_to_target = db.Column(db.DateTime)
date_posted = db.Column(db.DateTime, index=True, default=datetime.utcnow)
starting_price = db.Column(db.Float(30))
target_price = db.Column(db.Float(30), nullable=False)
confidence = db.Column(db.Integer)
convert = db.Column(db.Integer, default='USD')
price_difference = db.Column(db.Integer)
actual_price_difference = db.Column(db.Integer)
actual_price = db.Column(db.Integer)
def days_left(self):
current_date = datetime.utcnow().date()
target_date = self.date_to_target.date()
return abs((target_date - current_date).days)
def ping_actual_price(self):
get_price = cryptocompare.get_price(self.currency, self.convert)
self.actual_price = get_price[self.currency][self.convert]
db.session.add(self)
db.session.commit()
return self.actual_price
def ping_price_difference(self):
get_price = cryptocompare.get_price(self.currency, self.convert)
actual_price = get_price[self.currency][self.convert]
self.actual_price_difference = self.target_price - actual_price
db.session.add(self)
db.session.commit()
return self.actual_price_difference
def calculate_percentage(self):
diff = self.ping_price_difference()
result = ((self.price_difference - diff) / self.price_difference) * 100
return round(result)
def __repr__(self):
return '<Prediction>', self.currency, 'will be', self.target_price, 'from ', self.starting_price
class Employees(db.Model):
id = db.Column('employee_id', db.Integer, primary_key=True)
name = db.Column(db.String(100))
salary = db.Column(db.Float(50))
age = db.Column(db.String(200))
pin = db.Column(db.String(10))
def __init__(self, name, salary, age, pin):
self.name = name
self.salary = salary
self.age = age
self.pin = pin
class EvaluationSummary(db.Model):
__tablename__ = 'evaluation_summary'
id = db.Column(db.Integer, primary_key=True)
program_id = db.Column(db.Integer,
db.ForeignKey('academic_programs.id'))
survey_year = db.Column(db.Integer())
avg_analytics = db.Column(db.Float())
avg_professional = db.Column(db.Float())
avg_thinking = db.Column(db.Float())
avg_relation = db.Column(db.Float())
avg_knowledge = db.Column(db.Float())
avg_morals = db.Column(db.Float())
avg_identity = db.Column(db.Float())
avg_overall = db.Column(db.Float())
class requests(db.Model):
"""Model for the Requests table"""
__tablename__ = 'requests'
name = db.Column(db.String(50))
email = db.Column(db.String(128))
cell = db.Column(db.String(15))
company = db.Column(db.String(30))
integrator = db.Column(db.String(30))
funding_contact = db.Column(db.String(50))
address = db.Column(db.String(128))
city = db.Column(db.String(50))
state = db.Column(db.String(30))
zipcode = db.Column(db.Integer())
approved_integrator = db.Column(db.Boolean())
approved_facility = db.Column(db.Boolean())
facility = db.Column(db.String(30))
ion = db.Column(db.String(30))
energy = db.Column(db.Float())
id = db.Column(db.Integer(), primary_key=True)
funding_cell = db.Column(db.String(15))
funding_email = db.Column(db.String(128))
start = db.Column(db.DateTime, nullable=False)
ions = db.Column(db.ARRAY(db.Integer()))
comments = db.Column(db.String(200))
po_number = db.Column(db.Integer())
username = db.Column(db.String(200))
beam_time = db.Column(db.Integer())
scheduled_start = db.Column(db.DateTime)
integrator_comment = db.Column(db.String(200))
modified = db.Column(db.Boolean())
date_of_request = db.Column(db.DateTime)
status = db.Column(db.String(40))
rejected = db.Column(db.Boolean())
order = db.Column(db.Integer())
request_range = db.Column(db.Integer())
priority = db.Column(db.Boolean())
ion_hours = db.Column(db.ARRAY(db.Integer()))
shifts = db.Column(db.ARRAY(db.Integer()))
hoursOn = db.Column(db.ARRAY(db.Integer()))
hoursOff = db.Column(db.ARRAY(db.Integer()))
totalHours = db.Column(db.ARRAY(db.Integer()))
personnel = db.Column(db.String(200))
title = db.Column(db.String(200))
def create_request(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return "<Beam(id=%s, name=%s, facility=%s)>" % (self.id, self.name,
self.facility)
class JobSalary(db.Model):
__tablename__ = "jobsalaries"
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
title = db.Column(db.String(), nullable=False)
lower_quartile = db.Column(db.Integer(), nullable=False)
median_salary = db.Column(db.Integer(), nullable=False)
upper_quartile = db.Column(db.Integer(), nullable=False)
average_years_experience = db.Column(db.Float(), nullable=False)
last_updated = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
# books = db.relationship("Book", backref="user", lazy="dynamic")
def __repr__(self):
return f"<JobSalary {self.id}>"
class Calibration(db.Model):
__tablename__ = 'calibration'
id = db.Column(db.Integer(), primary_key=True)
offset_x = db.Column(db.Integer())
offset_y = db.Column(db.Integer())
offset_z = db.Column(db.Integer())
scale_x = db.Column(db.Float())
scale_y = db.Column(db.Float())
scale_z = db.Column(db.Float())
created = db.Column(db.String(20), nullable=False)
@staticmethod
def create(offsetX, offsetY, offsetZ, scaleX, scaleY, scaleZ):
calibration = Calibration()
calibration.offset_x = offsetX
calibration.offset_y = offsetY
calibration.offset_z = offsetZ
calibration.scale_x = scaleX
calibration.scale_y = scaleY
calibration.scale_z = scaleZ
calibration.created = str(int(dt.now().timestamp()))
return calibration
class Address(db.Model):
address_id = db.Column(db.Integer, primary_key=True)
user_type = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
latitude = db.Column(db.Float(255))
longitude = db.Column(db.Float(255))
address_line_one = db.Column(db.String(255))
address_line_two = db.Column(db.String(255))
pincode = db.Column(db.String(255))
city = db.Column(db.String(255))
landmark = db.Column(db.String(255))
def __init__(self, address_id, user_type, hotel_id, latitude, longitude,
address_line_one, address_line_two, pincode, city, landmark):
self.address_id = address_id
self.user_type = user_type
self.hotel_id = hotel_id
self.latitude = latitude
self.longitude = longitude
self.address_line_one = address_line_one
self.address_line_two = address_line_two
self.pincode = pincode
self.city = city
self.landmark = landmark
class Payment(db.Model):
__tablename__ = 'Payment'
hotel_id = db.Column(db.Integer)
user_id = db.Column(db.Integer, primary_key=True)
transaction_id = db.Column(db.String(255))
date_time = db.Column(db.dateTime)
amount = db.Column(db.Float(10))
mode = db.Column(db.String)
def __init__(self, hotel_id, user_id, transaction_id, date_time, amount,
mode):
self.hotel_id = hotel_id
self.user_id = user_id
self.transaction_id = transaction_id
self.date_time = db.Column(db.dateTime)
self.amount = amount
self.mode = mode
class PayrollsModel(db.Model):
__tablename__ = 'payrolls'
payroll_id = db.Column(db.Integer,primary_key=True)
month = db.Column(db.String(25),nullable=False)
gross_salary = db.Column(db.Float(25))
payee = db.Column(db.Float(25))
nhif = db.Column(db.Float(25))
nssf = db.Column(db.Float(25))
personal_relief = db.Column(db.Float(25))
sacco_distribution = db.Column(db.Float(25))
pension = db.Column(db.Float(25))
net_salary = db.Column(db.Float(25))
employee_id = db.Column(db.Integer,db.ForeignKey('employees.employee_id'))
# insert record: instance method
def insert_record(self):
db.session.add(self)
db.session.commit()
class Menu(db.Model):
menu_id = db.Column(db.Integer, primary_key=True)
chef_id = db.Column(db.Integer, db.ForeignKey('schedule.chef_id'))
food_item_name = db.Column(db.String(255))
price = db.Column(db.Float(10))
day = db.Column(db.String(255))
is_active = db.Column(db.Boolean)
photo = db.Column(db.String(255))
def __init__(self, menu_id, chef_id, food_item_name, price, day, is_active,
photo):
self.menu_id = menu_id
self.chef_id = chef_id
self.food_item_name = food_item_name
self.price = price
self.day = day
self.is_active = is_active
self.photo = photo
class Beams(db.Model):
"""Model for the Beams table"""
__tablename__ = 'Beams'
id = db.Column(db.Integer(), primary_key=True)
org_id = db.Column(db.Integer())
ion = db.Column(db.String(30))
amev = db.Column(db.Float())
max_energy = db.Column(db.Float())
let = db.Column(db.ARRAY(db.Float()))
beam_range = db.Column(db.Float())
max_flux = db.Column(db.Float())
air = db.Column(db.Boolean())
device = db.Column(db.String(30))
let_peak = db.Column(db.Float())
def __repr__(self):
return "<Beam(org_id=%s, ion=%s)>" % (self.org_id, self.ion)
class EmployeeModel(db.Model):
__tablename__='employees'
id=db.Column(db.Integer,primary_key=True)
full_name=db.Column(db.String(50),nullable=False)
gender = db.Column(db.String(20),nullable=False)
kra_pin=db.Column(db.String(20),unique=True,nullable=False)
email=db.Column(db.String(30),unique=True,nullable=True)
national_id=db.Column(db.String,unique=True,nullable=False)
department_id=db.Column(db.Integer,db.ForeignKey('departments.department_id'))
basic_salary=db.Column(db.Float(3))
benefits=db.Column(db.Float(3))
payrolls=db.relationship('PayrollsModel',backref='wafanyakazi', lazy=True)
#create
def insert_to_db(self):
db.session.add(self)
db.session.commit()
#read
@classmethod
def fetch_by_id(cls,id):
return cls.query.filter_by(id=id).first()
@classmethod
def fetch_all(cls):
return cls.query.all()
#update
@classmethod
#read on keyword functions
def update_by_id(cls,id,full_name=None,kra_pin=None,email=None,national_id=None,gender=None,basic_salary=None,department_id=None,benefits=None):
record= cls.fetch_by_id(id=id)
if full_name:
record.full_name=full_name
if gender:
record.gender = gender
if kra_pin:
record.kra_pin = kra_pin
if email:
record.email = email
if national_id:
record.national_id = national_id
if department_id:
record.department_id = department_id
if basic_salary:
record.basic_salary = basic_salary
if benefits:
record.benefits = benefits
db.session.commit()
return True
@classmethod
def update_dep_id(cls,id,department_id=None):
rec= cls.fetch_by_id(id=id)
if department_id:
rec.department_id = department_id
db.session.commit()
return True
#delete
@classmethod
def delete_by_id(cls,id):
record=cls.query.filter_by(id=id)
record.delete()
db.session.commit()
return True
class Funding(db.Model):
__tablename__ = 'fundings'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.UnicodeText())
year = db.Column(db.UnicodeText())
amount = db.Column(db.Float())
class Location(db.Model):
__tablename__ = 'location'
loc_id = db.Column(db.Integer(), primary_key=True)
lat_ = db.Column(db.Float(), nullable=True)
long_ = db.Column(db.Float(), nullable=True)
class EmployeesModel(db.Model):
__tablename__ = 'employees'
employee_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), nullable=False)
gender = db.Column(db.String(10), nullable=True)
email = db.Column(db.String(25), unique=True, nullable=False)
kra_pin = db.Column(db.String(25), unique=True, nullable=True)
start_date = db.Column(db.DateTime, default=datetime.now())
basic_salary = db.Column(db.Float(25), default=0)
benefits = db.Column(db.Float(25), default=0)
# user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
status = db.Column(db.Integer, default=0)
Payrolls = db.relationship(PayrollsModel, backref='employees')
#create method
def insert_method(self):
db.session.add(self)
db.session.commit()
#Readd
@classmethod
def fetch_all_records(cls):
return cls.query.filter_by(status=0)
# check email
@classmethod
def check_existing_email(cls, email):
record = cls.query.filter_by(email=email).first()
return record
# check kra
@classmethod
def check_existing_kra(cls, kra):
record = cls.query.filter_by(kra_pin=kra).first()
return record
#delete record
@classmethod
def delete_by_id(cls, id):
record = cls.query.filter_by(employee_id=id).first()
record.status = 1
db.session.commit()
return True
#update details
@classmethod
def update_by_id(cls,
id,
name=None,
email=None,
kra=None,
salary=None,
benefits=None):
record = cls.query.filter_by(employee_id=id).first()
if name:
record.name = name
if email:
record.email = email
if kra:
record.kra_pin = kra
if salary:
record.basic_salary = salary
if benefits:
record.benefits = benefits
db.session.commit()
return True
#fetch by id
@classmethod
def fetch_by_id(cls, id):
return cls.query.filter_by(employee_id=id).first()
