class Reservation(db.Model):
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'), nullable=False)
user_id = db.Column(db.Integer)
state = db.Column(db.String(50), nullable=False)
date_start = db.Column(db.DateTime, nullable=False)
date_end = db.Column(db.DateTime, nullable=False)
date_inserted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
date_updated = db.Column(db.DateTime,
onupdate=datetime.utcnow,
default=datetime.utcnow)
class SalesModel(db.Model):
id= db.Column(db.Integer,primary_key=True)
inventory_id = db.Column(db.Integer, db.ForeignKey('inventory.id'), nullable=False)
# inventory_id = db.Column(db.Integer, db.ForeignKey('inventory.id'), nullable=False)
# inventory_id = db.Column(db.Integer,nullable=False)f
quantity = db.Column(db.Integer,nullable=False)
def insert_to_db(self):
db.session.add(self)
db.session.commit()
class Tag(SpecialBase):
__tablename__ = "tag"
parent_id = db.Column(db.Integer,
db.ForeignKey('tag.id'),
nullable=True,
unique=False)
children = db.relationship('Tag', lazy=True)
def __repr__(self):
return f"Tag('{self.name}')"
db.UniqueConstraint('name', name='tag_uq')
class Media(db.Model):
__tablename__ = "medias"
id = db.Column(db.Integer, primary_key=True)
caption = db.Column(db.String(), nullable=False)
media_url = db.Column(db.String(), nullable=False)
permalink = db.Column(db.String(), nullable=True, unique=True)
thumbnail_url = db.Column(db.String(), nullable=False, unique=True)
timestamp = db.Column(db.Datetime, nullable=False, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __repr__(self):
return f"<Media {self.id}>"
class EnrollPaymentsModel(db.Model):
__tablename__ = 'enroll_payments'
id = db.Column(db.Integer, primary_key=True)
ube_id = db.Column(db.Integer,
db.ForeignKey('user_bootcamp_enrollments.id'))
amount = db.Column(db.Float, nullable=False)
msis_dn = db.Column(db.String, nullable=False)
mpesa_ref = db.Column(db.String, nullable=False)
# add new users
def newUsers(self):
db.session.add(self)
db.session.commit()
class Profile(db.Model):
__tablename__ = "profiles"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False, unique=True)
lastname = db.Column(db.String(), nullable=False)
biography = db.Column(db.String(), nullable=False)
profilepic = db.Column(db.String(), nullable=False, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __repr__(self):
return f"<Profile {self.username}>"
class IOCode(db.Model):
__tablename__ = 'iocodes'
id = db.Column('id', db.String(16), primary_key=True)
cost_center_id = db.Column('cost_center_id',
db.String(),
db.ForeignKey('cost_centers.id'),
nullable=False)
cost_center = db.relationship('CostCenter', backref=db.backref('iocodes'))
mission_id = db.Column('mission_id',
db.Integer(),
db.ForeignKey('missions.id'),
nullable=False)
mission = db.relationship('Mission', backref=db.backref('iocodes'))
org_id = db.Column('org_id',
db.Integer(),
db.ForeignKey('orgs.id'),
nullable=False)
org = db.relationship('Org', backref=db.backref('iocodes'))
name = db.Column('name', db.String(255), nullable=False)
def __repr__(self):
return u'{}:{}'.format(self.id, self.name)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
def __init__(self, title, content, author):
self.title = title
self.content = content
self.user_id = author
class Store(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True)
storename = db.Column(db.String(), nullable=False, unique=True)
firstname = db.Column(db.String(), nullable=False)
lastname = db.Column(db.String(), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
product = db.relationship("Product", backref="store")
customer = db.relationship("Customer", backref="store")
def __repr__(self):
return f"<Store {self.storename}, {self.id}>"
class Rating(db.Model):
id = db.Column(db.Integer, primary_key=True)
stars = db.Column(db.Float)
username = db.Column(db.String, default='Anonymous')
review = db.Column(db.String)
doctor_id = db.Column(db.Integer, db.ForeignKey('doctor.id'),
nullable=False)
def serialize(self):
return {"id": self.id,
"stars": self.stars,
"username": self.username,
"review": self.review}
class List(db.Model):
__tablename__ = "lists"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
content = db.Column(db.String())
board_id = db.Column(db.Integer,
db.ForeignKey("boards.id"),
nullable=False)
cards = db.relationship("Card", backref="list", lazy="dynamic")
def __repr__(self):
return f"<List {self.title}>"
class Image(db.Model):
__tablename__ = "images"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(),
db.ForeignKey("users.username"),
nullable=False)
path = db.Column(db.String(), nullable=False)
last_updated = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
def __repr__(self):
return f"<Image {self.id}>"
class Comment(db.Model):
__tablename__ = "Comment"
id = db.Column(db.Integer, primary_key=True, nullable=False)
masterpiece_id = db.Column(db.Integer, nullable=False)
content = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('User.id', ondelete='CASCADE'), nullable=False)
def __init__(self, masterpiece_id, content, date, user_id):
self.masterpiece_id = masterpiece_id
self.content = content
self.date = date
self.user_id = user_id
class Org(db.Model):
__tablename__ = 'orgs'
id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True)
name = db.Column('name', db.String(), nullable=False)
en_name = db.Column('en_name', db.String())
head = db.Column('head', db.String())
parent_id = db.Column('parent_id', db.Integer, db.ForeignKey('orgs.id'))
children = db.relationship('Org',
backref=db.backref('parent', remote_side=[id]))
strategies = db.relationship('Strategy', backref=db.backref('org'))
def __repr__(self):
return self.name
class KPI(db.Model):
__tablename__ = 'kpis'
id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True)
created_by = db.Column('created_by', db.String())
created_at = db.Column('created_at',
db.DateTime(),
server_default=func.now())
updated_at = db.Column('updated_at',
db.DateTime(),
server_default=func.now())
updated_by = db.Column('updated_by', db.String())
name = db.Column('name', db.String, nullable=False)
refno = db.Column('refno', db.String())
intent = db.Column('intent', db.String())
frequency = db.Column('frequency', db.Integer())
unit = db.Column('unit', db.String())
source = db.Column('source', db.String())
available = db.Column('available', db.Boolean())
availability = db.Column('availability', db.String())
formula = db.Column('formula', db.String())
keeper = db.Column('keeper', db.String(),
db.ForeignKey('staff_account.email'))
note = db.Column('note', db.String())
target = db.Column('target', db.String())
target_source = db.Column('target_source', db.String())
target_setter = db.Column('target_setter', db.String())
target_reporter = db.Column('target_reporter', db.String())
target_account = db.Column('target_account', db.String())
reporter = db.Column('reporter', db.String())
consult = db.Column('consult', db.String())
account = db.Column('account', db.String())
informed = db.Column('informed', db.String())
pfm_account = db.Column('pfm_account', db.String())
pfm_responsible = db.Column('pfm_resposible', db.String())
pfm_consult = db.Column('pfm_consult', db.String())
pfm_informed = db.Column('pfm_informed', db.String())
strategy_activity_id = db.Column('strategy_activity_id',
db.ForeignKey('strategy_activities.id'))
reportlink = db.Column('reportlink', db.String())
class StrategyTactic(db.Model):
__tablename__ = 'strategy_tactics'
id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True)
refno = db.Column('refno', db.String(), nullable=False)
created_at = db.Column('created_at',
db.DateTime(),
server_default=func.now())
content = db.Column('content', db.String(), nullable=False)
strategy_id = db.Column('strategy_id',
db.Integer(),
db.ForeignKey('strategies.id'),
nullable=False)
themes = db.relationship('StrategyTheme', backref=db.backref('tactic'))
class Document(db.Model):
__tablename__ = "documents"
id = db.Column(db.Integer, primary_key=True)
docname = db.Column(db.String())
user_id = db.Column(db.Integer,
db.ForeignKey("accounts.id"),
nullable=False)
# doc_images = db.relationship("DocImage", backref="document", lazy="dynamic")
def __repr__(self):
return f"<Document {self.docname}>"
class Factura(db.Model):
id = db.Column(db.Integer, primary_key=True)
cliente_id = db.Column(db.Integer, db.ForeignKey('cliente.id'))
productos = db.relationship('Producto',
secondary=products_fac,
backref=db.backref('productosfacturados',
lazy='dynamic'))
cantidad_productos = db.Column(db.Integer, default=0)
valor_total = db.Column(db.Integer, default=0)
metodo_pago = db.Column(db.String(50))
def __repr__(self):
return '<Nombre %r>' % self.nombre
class Product(db.Model, CapacityMixin, InheritedAttributesMixin):
""" A product (ticket or other item) which is for sale. """
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer,
db.ForeignKey(ProductGroup.id),
nullable=False)
name = db.Column(db.String, nullable=False)
display_name = db.Column(db.String)
description = db.Column(db.String)
price_tiers = db.relationship('PriceTier',
backref='parent',
cascade='all',
order_by='PriceTier.id')
product_view_products = db.relationship('ProductViewProduct',
backref='product')
__table_args__ = (UniqueConstraint('name', 'group_id'), )
@classmethod
def get_by_name(cls, group_name, product_name):
group = ProductGroup.query.filter_by(name=group_name)
product = group.join(Product).filter_by(
name=product_name).with_entities(Product)
return product.one_or_none()
@property
def purchase_count_by_state(self):
states = Purchase.query.join(PriceTier, Product) \
.filter(Product.id == self.id) \
.with_entities(Purchase.state, func.count(Purchase.id)) \
.group_by(Purchase.state)
return dict(states)
def get_cheapest_price(self, currency='GBP'):
price = PriceTier.query.filter_by(product_id=self.id) \
.join(Price).filter_by(currency=currency) \
.with_entities(Price) \
.order_by(Price.price_int).first()
return price
def get_price_tier(self, name):
tier = PriceTier.query.filter_by(product_id=self.id) \
.filter_by(name=name)
return tier.one_or_none()
def __repr__(self):
return "<Product: %s>" % self.name
def __str__(self):
return self.name
class Foundation(db.Model):
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String, unique=True)
wg_tag = db.Column(db.String(10))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('foundation', lazy=True))
width = db.Column(db.Float)
depth = db.Column(db.Float)
thickness = db.Column(db.Float)
length = db.Column(db.Float)
amount = db.Column(db.Integer)
top_bar_type = db.Column(db.String(20))
mid_bar_type = db.Column(db.String(20))
bot_bar_type = db.Column(db.String(20))
stir_bar_type = db.Column(db.String(20))
top_bar_amt = db.Column(db.Integer)
mid_bar_amt = db.Column(db.Integer)
bot_bar_amt = db.Column(db.Integer)
stir_spacing = db.Column(db.Float)
timestamp = db.Column(db.String, default=time.ctime())
def __repr__(self):
return '<Structural Member Foundation {}'.format(self.tag)
def __init__(self, doc_id, tag, wg_tag, width, depth, thickness, length,
amount, category, top_bar, mid_bar, bot_bar, stirup,
stirup_spacing, amt_top, amt_mid, amt_bot):
self.tag = tag
self.wg_tag = wg_tag
self.width = width
self.length = length
self.depth = depth
self.thickness = thickness
self.amount = amount
self.top_bar_type = top_bar
self.mid_bar_type = mid_bar
self.bot_bar_type = bot_bar
self.stir_bar_type = stirup
self.top_bar_amt = amt_top
self.mid_bar_amt = amt_mid
self.bot_bar_amt = amt_bot
self.stir_spacing = stirup_spacing
class Devices(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
ip = db.Column(db.String(100))
barcode = db.Column(db.String(100))
device_key = db.Column(db.String(1000),
nullable=False,
default=random_gen())
command = db.Column(db.String(100), nullable=False)
state = db.Column(db.Integer, nullable=False, default=0)
description = db.Column(db.String(500))
typeId = db.Column(db.Integer, db.ForeignKey("device_types.id"))
flatId = db.Column(db.Integer, db.ForeignKey("flats.id"))
roomId = db.Column(db.Integer, db.ForeignKey("rooms.id"))
dateAdded = db.Column(db.DateTime, nullable=False, default=datetime.now)
pins = db.relationship('Pins', backref='devices', lazy='joined')
sensors = db.relationship('Sensors', backref='devices', lazy='joined')
sensor_records = db.relationship('Sensor_records',
backref='devices',
lazy=True)
schedules = db.relationship('Schedules', backref='devices', lazy=True)
def json(self):
device = {
"id": self.id,
"name": self.name,
"ip": self.ip,
"barcode": self.barcode,
"device_key": self.device_key,
"command": self.command,
"state": self.state,
"description": self.description,
"typeId": self.typeId,
"flatId": self.flatId,
"roomId": self.roomId,
"dateAdded": self.dateAdded
}
return device
class MonitorCryingSensorData(db.Model):
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
crying = db.Column(db.Boolean)
monitor_crying_sensor_id = db.Column(
db.Integer, db.ForeignKey("monitor_crying_sensor.id"))
def __repr__(self):
return "<MonitorCryingSensorData {}>".format(self.id)
def created(self):
return self.created_at.strftime("%d/%m/%Y %H:%M:%S")
class BatteryAuditTable(db.Model):
__tablename__ = 'battery_audit_table'
_id = db.Column(db.Integer, primary_key=True, unique=True)
audit_id = db.Column(db.Integer,
db.ForeignKey('task_table.audit_id'),
nullable=False)
emp_id = db.Column(db.Integer,
db.ForeignKey('users_login.emp_id'),
nullable=False)
power_sup_loc = db.Column(db.String(20))
power_sup_sock = db.Column(db.String(20))
battery_avail = db.Column(db.String(5))
battery_conn_cx = db.Column(db.String(5))
voltage = db.Column(db.String(5))
battery_type = db.Column(db.String(5))
capacity = db.Column(db.String(5))
install_date = db.Column(db.String(25))
serial = db.Column(db.Integer)
check_point_t1 = db.Column(db.Float) # First 15 Min Discharging Test
check_point_t2 = db.Column(db.Float) # Second 15 Min Discharging Test
check_point_t3 = db.Column(
db.String(5)) # Is Battery going down on Starting the Discharging Test
is_battery_changed = db.Column(db.String(5))
class Ad(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
datePosted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
description = db.Column(db.Text, nullable=False)
userId = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
images = db.relationship('Image', backref='author', lazy=True, cascade="delete")
payingTypes = db.relationship('PayingType', secondary=payingTypes, lazy='subquery',
backref=db.backref('ads', lazy=True), cascade="delete")
books = db.relationship('Book', backref='ad', lazy=True, cascade="delete")
def __repr__(self):
return f"Post('{self.title}', '{self.datePosted}')"
class RfidTag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
residentId = db.Column(db.Integer, db.ForeignKey("resident.id"))
description = db.Column(db.String(500))
def json(self):
rfidTags = {
"id": self.id,
"name": self.name,
"residentId": self.residentId,
"description": self.description
}
return rfidTags
class Sprint(db.Model): # Creating a Users class inheriting from db.Model
__tablename__ = "sprints"
id = db.Column(db.Integer, primary_key=True)
meeting_point = db.Column(db.String(), nullable=False)
creation_time = db.Column(db.DateTime, nullable=False)
league_id = db.Column(db.Integer,
db.ForeignKey("leagues.id"),
nullable=False)
points = db.relationship("Point", backref=backref("sprint"))
def __repr__(
self): # When printing the model we will see its email attribute
return f"<Sprint {self.creation_time}>"
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, db.ForeignKey('states.id'))
# relationship variable, to list all the user_roles
towns = db.relationship('Towns', backref='enquiry', lazy=True)
institutions = db.relationship('Institutions', backref='enquiry', lazy=True)
def __repr__(self):
return '{"id":{0}, "district":{1}}'.format(self.id, self.district)
@classmethod
def get_all_districts(cls):
districts = Districts.query.all()
districts_json = [district.serialize() for district in districts]
return districts_json
@classmethod
def get_district_from_id(cls, id):
district = cls.query.get(id)
return district
@classmethod
def delete_district_from_id(cls, id):
district = cls.get_district_from_id(id)
if district is None:
return None
db.session.delete(district)
db.session.commit()
return district
@classmethod
def submit_district_from_json(cls, json_district):
district = cls(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,
'towns': [town.serialize() for town in self.towns],
'Institutions': [institution.serialize() for institution in self.institutions]
}
return json_district
class ProfileImage(db.Model):
__tablename__ = "profile_images" # explicitly providing the name of the table
id = db.Column(
db.Integer, primary_key=True
) # creates a column called id, sets it as an integer and links it to a primary key
filename = db.Column(db.String(), nullable=False,
unique=True) # profilename, string, must be present
profile_id = db.Column(
db.Integer, db.ForeignKey(".id"),
nullable=False) # profile id, integer, foreign key, must be present
def __repr__(self):
return f"<ProfileImage {self.filename}>"
class Customer(db.Model):
__tablename__ = "customers"
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(), nullable=False)
lastname = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), nullable=False, unique=True)
phone = db.Column(db.String())
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"),
nullable=False)
order = db.relationship("Order", backref="customer")
def __repr__(self):
return f"<Customer {self.firstname}, {self.lastname}, {self.email}>"
class ApplyTalent(db.Model):
__tablename__ = 'apply_talent'
id = db.Column(db.Integer, primary_key=True)
talent_id = db.Column(db.Integer,
db.ForeignKey('talent.id', ondelete='cascade'),
nullable=False)
contributor_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='cascade'),
nullable=False)
completed_at = db.Column(db.DateTime, nullable=True)
talent = db.relationship('Talent', back_populates='apply_talent')
def get_data(self):
completed_at = int(
self.completed_at.timestamp()) if self.completed_at else None
return {
'id': self.id,
'talent_id': self.talent_id,
'contributor_id': self.contributor_id,
'completed_at': completed_at
}
