class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
passwd = db.Column(db.String(80))
auth = db.Column(db.Integer)
admin = db.Column(db.Integer)
def __init__(self, name, passwd, auth=0, admin=0):
self.name = name
self.passwd = passwd
self.auth = auth
self.admin = admin
def is_authenticated(self):
return self.auth
def is_admin(self):
return self.admin
def auth_toggle(self):
if self.auth:
self.auth = 0
else:
self.auth = 1
db.session.commit()
class Guest(db.Model):
__tablename__ = 'guest'
__table_args__ = (db.UniqueConstraint('name', 'arrival', 'apartment_id'),
db.Index('guest_idx', 'name', 'arrival', 'apartment_id'))
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
arrival = db.Column(db.DateTime, nullable=False)
active = db.Column(db.SmallInteger, default=1)
apartment_id = db.Column(db.Integer,
db.ForeignKey('apartment.id', ondelete='CASCADE'),
nullable=False)
apartment = db.relationship(
'Apartment',
backref=db.backref(
'guests',
lazy=True,
cascade='all, delete',
primaryjoin=
'and_(Guest.apartment_id == Apartment.id, Guest.active == 1)'),
lazy=True,
primaryjoin=
'and_(Guest.apartment_id == Apartment.id, Apartment.active == 1)')
def __repr__(self):
return f'Guest(id={self.id}, name={self.name}, arrival={self.arrival})'
class Rule(db.Model):
__tablename__ = 'rule'
__table_args = (db.UniqueConstraint('text', 'condominium_id'),
db.Index('rule_idx', 'text'))
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
employee_id = db.Column(db.Integer,
db.ForeignKey('employee.id', ondelete='CASCADE'),
nullable=False)
condominium_id = db.Column(db.Integer,
db.ForeignKey('condominium.id',
ondelete='CASCADE'),
nullable=False)
author = db.relationship('Employee',
backref=db.backref('rules',
lazy=True,
cascade='all, delete'),
lazy=False)
condominium = db.relationship(
'Condominium',
backref=db.backref('rules', lazy=True, cascade='all, delete'),
lazy=True,
primaryjoin=
'and_(Rule.condominium_id == Condominium.id, Condominium.active == 1)')
def __repr__(self):
return f'Rule(text={self.text})'
class Note(db.Model):
__tablename__ = 'note'
note_id = db.Column(db.Integer, primary_key=True)
c_id = db.Column(db.Integer, db.ForeignKey('company.c_id'))
content = db.Column(db.String, nullable=False)
timestamp = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
class Note(db.Model):
__bind_key__ = 'notes'
__tablename__ = 'note'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
datetime = db.Column(db.String)
user = db.Column(db.String(100))
content = db.Column(db.String)
class Country(db.Model):
__tablename__ = 'country'
__table_args__ = (db.UniqueConstraint('name'), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False, index=True)
def __repr__(self):
return f'Country(id={self.id}, name={self.name})'
class SuperUser(db.Model):
__tablename__ = 'super_user'
__table_args__ = (db.UniqueConstraint('username'),
db.UniqueConstraint('password'))
username = db.Column(db.String(100), primary_key=True)
password = db.Column(db.String(200), nullable=False)
def __repr__(self):
return f'SuperUser(username={self.username})'
class Employee(db.Model):
__tablename__ = 'employee'
__table_args__ = (
db.UniqueConstraint('cpf', 'role', 'condominium_id'),
db.Index('employee_idx', 'cpf', 'role', 'condominium_id')
)
id = db.Column(db.Integer, primary_key=True)
cpf = db.Column(db.String(11), nullable=False)
name = db.Column(db.String(50), nullable=False)
birthday = db.Column(db.Date, nullable=False)
photo_location = db.Column(db.String(200), nullable=True, default='data/photos/default/employee.png')
role = db.Column(db.String(50), nullable=False)
type = db.Column(db.SmallInteger, nullable=False)
condominium_id = db.Column(db.Integer, db.ForeignKey('condominium.id', ondelete='CASCADE'), nullable=False)
active = db.Column(db.SmallInteger, default=1)
condominium = db.relationship('Condominium',
backref=db.backref('employees', lazy=True, cascade='all, delete'),
lazy=True,
primaryjoin='and_(Employee.condominium_id == Condominium.id, Condominium.active == 1)')
def __repr__(self):
return f'Employee(id={self.id}, ' \
f'cpf={self.cpf}, ' \
f'name={self.name}, ' \
f'birthday={self.birthday}, ' \
f'role={self.role})'
class ShoppingCart(db.Model):
__tablename__ = 'ShoppingCart'
cartID = db.Column(db.Integer, primary_key=True)
customerID = db.Column(db.Integer, nullable=False)
def __init__(self, customerId):
self.customerID = customerId
def __repr__(self):
return '<ShoppingCart: {}, customer: {}>'.format(
self.cartID, self.customerID)
class Room(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True)
description = db.Column(db.String(500))
reservable = db.Column(db.Boolean, nullable=False)
reservations = db.relationship('Reservation',
backref='room',
lazy='dynamic')
def __repr__(self):
return '<Room: %s>' % self.name
class Employee(db.Model):
id = db.Column(db.Integer(), primary_key=True)
department_id = db.Column(db.Integer, db.ForeignKey('department.id'))
name = db.Column(db.Integer())
date_of_birth = db.Column(db.Date, nullable=False)
salary = db.Column(db.Integer())
def __repr__(self):
return str(self.id) + ' ' + self.name + ' ' + str(
self.date_of_birth) + ' ' + str(self.salary) + ' ' + str(
self.department_id)
class DataSet(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(80))
project_name = db.Column(db.String(80))
screen_img = db.Column(db.String(80))
camera_img = db.Column(db.String(80))
def __init__(self, date, project_name, screen_img, camera_img):
self.date = date
self.project_name = project_name
self.screen_img = screen_img
self.camera_img = camera_img
class Show(db.Model):
__tablename__ = 'show'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime())
artist_id = db.Column(db.Integer,
db.ForeignKey('artist.id'),
nullable=False)
venue_id = db.Column(db.Integer, db.ForeignKey('venue.id'), nullable=False)
def __repr__(self):
return f'<Show of the Artist that his ID: { self.artist_id } , and the venue ID: { self.venue_id }>'
class Genre(db.Model):
__tablename__ = 'genre'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1000), unique=True, nullable=False)
movies = db.relationship('Movie')
def __repr__(self):
return f"Genre('{self.name}')"
@property
def serialize(self):
return {'id': self.id, 'name': self.name}
class Test(db.Model): #test table definitions
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
value1 = db.Column(db.String(512), nullable=False)
value2 = db.Column(db.String(512), nullable=False)
def __init__(self, value1, value2):
self.value1 = value1
self.value2 = value2
def __repr__(self): #this is what you get if you print Test Object
return '<Test %r>' % self.value1
#db.create_all
class Users(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) password = db.Column(db.String(512), nullable=False) dob = db.Column(db.DateTime, nullable=False) email = db.Column(db.String(512), unique=True) name = db.Column(db.String(512), nullable=False) phone = db.Column(db.String(10), nullable=False, unique=True) image = db.Column(db.String(512)) role = db.Column(db.String(128)) def __init__(self, password, dob, email, name, phone, image, role): self.password = password self.dob = dob self.email = email self.name = name self.phone = phone self.image = image self.role = role @login_manager.user_loader def load_user(user_id): return Users.query.get(int(user_id)) def __repr__(self): return '<User %r>' % self.name
class Record(db.Model):
id = db.Column(db.Integer, primary_key=True)
datetime = db.Column(db.DateTime, default=datetime.now, nullable=False)
# time = db.Column(db.Text, nullable=True)
text = db.Column(db.String(250), nullable=False)
num_calories = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
# In user model, Test is started with capital letter because we are using the actual Test class.
# But here we use 'user.id' with small u because it is actual table in db, and actual column
# table and column name are simply lowercase by default
def __repr__(self):
return f"Record('{self.id}, {self.datetime}, {self.text}, {self.num_calories}, {self.user_id}')"
class Actual(db.Model):
#__tablename__ = 'actuals'
id = db.Column(db.Integer, primary_key=True)
temp = db.Column(db.Integer)
rain = db.Column(db.Integer)
date = db.Column(db.Date)
crag_id = db.Column(db.Integer, db.ForeignKey('crag.id'))
crag = db.relationship("Crag", backref=db.backref("actuals", lazy='dynamic'))
def __repr__(self):
return "<Actual(crag=%s, temp=%d, rain=%s, date=%s>" % (
self.crag_id, self.temp, self.rain,
self.date.strftime("%b %d %y"))
class Customer(db.Model):
__tablename__ = 'Customer'
customerID = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), index=True, unique=True, nullable=False)
name = db.Column(db.String(64), nullable=False)
phoneNum = db.Column(db.String(64))
creditCardID = db.relationship('CreditCard', backref='customer', lazy=True)
addressID = db.relationship('Address', backref='customer', lazy=True)
def __init__(self, email, name):
self.email = email
self.name = name
def __repr__(self):
return '<Customer: {}, customer: {}>'.format(self.customerID,
self.email)
class CRUDMixin(object):
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
@classmethod
def get_by_id(cls, id):
if any(
(isinstance(id, str) and id.isdigit(),
isinstance(id, (int, float))),
):
return cls.query.get(int(id))
return None
@classmethod
def create(cls, **kwargs):
instance = cls(**kwargs)
return instance.save()
def update(self, commit=True, **kwargs):
for attr, value in kwargs.iteritems():
setattr(self, attr, value)
return commit and self.save() or self
def save(self, commit=True):
db.session.add(self)
if commit:
db.session.commit()
return self
def delete(self, commit=True):
db.session.delete(self)
return commit and db.session.commit()
class Crag(db.Model):
#__tablename__ = 'crags'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
## Note lat and lng are scaled by 100 e.g. 75.65 lat stored as 7565
lat = db.Column(db.Integer)
lng = db.Column(db.Integer)
wu_name = db.Column(db.String)
#forecasts = db.relationship("Forecast", backref=db.backref('crag'))
#actuals = db.relationship("Actual", backref=db.backref('crag'))
def __repr__(self):
return "<Crag(name=%s, lat=%d, lng=%d, wu_name=%s)>" % (
self.name, self.lat, self.lng, self.wu_name)
class CartItem(db.Model):
__tablename__ = 'CartItem'
cartItemID = db.Column(db.Integer, primary_key=True)
SKU = db.Column(db.Integer, nullable=False)
cartID = db.Column(db.Integer, nullable=False)
quantity = db.Column(db.Integer, nullable=False)
status = db.Column(db.String(15), nullable=False)
def __init__(self, SKU, cartID, quantity):
self.SKU = SKU
self.cartID = cartID
self.quantity = quantity
self.status = 'UNFILLED'
def __repr__(self):
return '<CartItem {}, cartID: {}>'.format(self.SKU, self.cartID)
class IncomingTransaction(db.Model):
__tablename__ = 'IncomingTransaction'
batchID = db.Column(db.Integer, primary_key=True)
SKU = db.Column(db.Integer, nullable=False)
producer = db.Column(db.String(32), nullable=False)
transactionDate = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, batchID, SKU, producer):
self.batchID = batchID
self.SKU = SKU
self.producer = producer
def __repr__(self):
return '<IncomingTransaction {}>'.format(self.batchID)
class Address(db.Model):
__tablename__ = 'address'
__table_args__ = (db.UniqueConstraint('street_name', 'city_id'), db.Index('address_idx', 'street_name', 'city_id'))
id = db.Column(db.Integer, primary_key=True)
street_name = db.Column(db.String(150), nullable=False)
neighbourhood = db.Column(db.String(150), nullable=False)
city_id = db.Column(db.Integer, db.ForeignKey('city.id', ondelete='CASCADE'), nullable=False)
city = db.relationship('City', backref=db.backref('addresses', lazy=True, cascade='all, delete'), lazy=False)
def __repr__(self):
return f'Address(id={self.id}, ' \
f'street_name={self.street_name}, ' \
f'neighbourhood={self.neighbourhood}, ' \
f'city_name={self.city.name})'
class Tower(db.Model):
__tablename__ = 'tower'
__table_args__ = (db.UniqueConstraint('name', 'condominium_id'), db.Index('tower_idx', 'name', 'condominium_id'))
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10), nullable=False)
condominium_id = db.Column(db.Integer, db.ForeignKey('condominium.id', ondelete='CASCADE'), nullable=False)
active = db.Column(db.SmallInteger, default=1)
condominium = db.relationship('Condominium',
backref=db.backref('towers', lazy=True, cascade='all, delete'),
lazy=True,
primaryjoin='and_(Tower.condominium_id == Condominium.id, Condominium.active == 1)')
def __repr__(self):
return f'Tower(id={self.id}, ' \
f'tower_name={self.name})'
class Department(db.Model):
__tablename__ = 'department'
__table_args__ = {'mysql_engine': 'InnoDB'}
name = db.Column(db.String(64), primary_key=True)
head = db.relationship('Head',
backref='department',
passive_deletes=True,
uselist=False)
class Product(db.Model):
__tablename__ = 'Product'
SKU = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), index=True, unique=True, nullable=False)
category = db.Column(db.String(16), nullable=False)
price = db.Column(db.Numeric(4,2), nullable=False)
reorder_point = db.Column(db.Integer, nullable=False)
stock_quantity = db.Column(db.Integer, default=0, nullable=False)
storage_location = db.Column(db.String(24), nullable=False)
batches = db.relationship('ProductBatch', backref='product', lazy=True)
def __init__(self, SKU, name, category, price, reorder_point, storage_location):
self.SKU = SKU
self.name = name
self.category = category
self.price = price
self.reorder_point = reorder_point
self.storage_location = storage_location
def __repr__(self):
return '<Product {}, {}>'.format(self.SKU, self.name)
def update_stock_quantity(self):
total = 0
for batch in self.batches:
total += batch.batch_quantity
self.stock_quantity = int(total)
class Employee(db.Model):
__tablename__ = 'employee'
__table_args__ = {'mysql_engine': 'InnoDB'}
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(64), nullable=False)
last_name = db.Column(db.String(64), nullable=False)
salary = db.Column(db.Integer, nullable=True)
department = db.Column(db.String(64),
db.ForeignKey('department.name',
ondelete='SET NULL',
onupdate='CASCADE'),
nullable=True)
birth_date = db.Column(db.Date, nullable=False)
hire_date = db.Column(db.Date, nullable=False, default=date.today())
dept = db.relationship('Department',
backref=db.backref('employee',
passive_deletes=True,
passive_updates=True))
head = db.relationship('Head',
backref='employee',
passive_deletes=True,
uselist=False)
def serialize(self):
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'salary': self.salary,
'department': self.department,
'birth_date': dump_date(self.birth_date),
'hire_date': dump_date(self.hire_date)
}
class ProductBatch(db.Model):
__tablename__ = 'ProductBatch'
batchID = db.Column(db.Integer, primary_key=True)
SKU = db.Column(db.Integer, db.ForeignKey('Product.SKU'), nullable=False)
producer = db.Column(db.String(24), nullable=False)
batch_quantity = db.Column(db.Integer, nullable=False)
batch_expiration = db.Column(db.DateTime, nullable=False)
def __init__(self, SKU, producer, batch_quantity, batch_expiration):
self.SKU = SKU
self.batch_quantity = batch_quantity
self.producer = producer
# datetime.datetime(year, month, day)
self.batch_expiration = batch_expiration
def __repr__(self):
return '<ProductBatch {}, {}>'.format(self.batchID, self.SKU)
class Head(db.Model):
__tablename__ = 'head'
__table_args__ = {'mysql_engine': 'InnoDB'}
department_name = db.Column(db.String(64),
db.ForeignKey('department.name',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True)
head_id = db.Column(db.Integer,
db.ForeignKey('employee.id',
ondelete='SET NULL',
onupdate='CASCADE'),
nullable=True)
def serialize(self):
return {
'department_name': self.department_name,
'head_id': self.head_id,
}
