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, }