class Beam(db.Model):
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String, unique=True)
wall_tag = db.Column(db.String(10))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('caregory', lazy=True))
width = db.Column(db.Float)
depth = db.Column(db.Float)
length = db.Column(db.Float)
amount = db.Column(db.Integer)
timestamp = db.Column(db.String, default=time.ctime())
def __init__(self, doc_id, tag, wall_tag, width, depth, length, amount,
category, top_bar, mid_bar, bot_bar, stirup, stirup_spacing,
amt_top, amt_mid, amt_bot):
self.tag = tag
self.wall_tag = wall_tag
self.width = width
self.length = length
self.depth = depth
self.amount = amount
def __repr__(self):
return '<Structural Member Beam {}'.format(self.tag)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
value = 'User({}, {}, {})'.format(self.username, self.email,
self.image_file)
return value
class PayrollsModel(db.Model):
__tablename__ = "payrolls"
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(50), nullable=False)
month = db.Column(db.String, unique=True)
gross_salary = db.Column(db.Integer)
nhif = db.Column(db.Float)
nssf = db.Column(db.Float)
paye = db.Column(db.Float)
loan_deducted = db.Column(db.Float)
salary_advance = db.Column(db.Float)
overtime = db.Column(db.Float)
personal_relief = db.Column(db.Float)
taxable_income = db.Column(db.Float)
net_salary = db.Column(db.Float)
take_home_pay = db.Column(db.Float)
employee_id = db.Column(db.Integer,
db.ForeignKey('employees.id'),
nullable=False)
employee = db.relationship('EmployeeModel', backref='pay')
def insert_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def fetch_by_employee(cls, id):
return cls.query.filter_by(id=id)
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
shelters = db.relationship("Shelter", backref="user")
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(20), nullable=False)
admin = db.Column(db.Boolean, nullable=False)
sensor = db.relationship('Sensor', back_populates='user')
def __repr__(self):
return '<User: %r >' % (self.email)
#convert to JSON
def to_json(self):
user_json = {
'id': self.id,
'email': str(self.email),
'password': str(self.password),
'admin': self.admin
}
return user_json
# convert JSON to object
@staticmethod
def from_json(user_json):
email = user_json.get('email')
password = user_json.get('password')
admin = user_json.get('admin')
return User(email=email, password=password, admin=admin)
class Categoria(db.Model):
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
productos = db.relationship('Producto', backref='cat')
def __repr__(self):
return '<Nombre %r>' % self.nombre
class ProjectProgress(db.Model, ModelUtils):
__tablename__ = 'project_progress'
id = db.Column(db.Integer, primary_key=True)
created_asof = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_asof = db.Column(db.DateTime, onupdate=datetime.datetime.utcnow)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
project = db.relationship(
'Project', backref="progress", foreign_keys=[project_id])
value = db.Column(db.Integer, nullable=False)
note = db.Column(db.Text)
REQUIRED_POST_FIELDS = ['value']
API_REPRESENTATION = {
'id': fields.Integer,
'created_asof': fields.DateTime,
'updated_asof': fields.DateTime,
'project_id': fields.Integer,
'value': fields.Integer,
'notes': fields.String
}
class Role(db.Model):
id = db.Column(mysql.INTEGER(50), primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
users = db.relationship("User")
create_player = db.Column(db.Boolean, unique=False, nullable=False)
modify_player = db.Column(db.Boolean, unique=False, nullable=False)
delete_player = db.Column(db.Boolean, unique=False, nullable=False)
create_rep = db.Column(db.Boolean, unique=False, nullable=False)
modify_rep = db.Column(db.Boolean, unique=False, nullable=False)
delete_rep = db.Column(db.Boolean, unique=False, nullable=False)
toggle_market = db.Column(db.Boolean, unique=False, nullable=False)
give_points = db.Column(db.Boolean, unique=False, nullable=False)
create_game = db.Column(db.Boolean, unique=False, nullable=False)
update_game = db.Column(db.Boolean, unique=False, nullable=False)
delete_game = db.Column(db.Boolean, unique=False, nullable=False)
admin_panel = db.Column(db.Boolean, unique=False, nullable=False)
def __repr__(self):
return 'id:%r name:%r' % (self.id, self.name)
def toJSON(self):
permissions = [
'create_player', 'modify_player', 'delete_player', 'create_rep',
'modify_rep', 'delete_rep', 'toggle_market', 'give_points',
'create_game', 'update_game', 'delete_game', 'admin_panel'
]
has_permissions = []
for p in permissions:
if getattr(self, p):
has_permissions.append(p)
return {
'id': self.id,
'name': self.name,
'permissions': has_permissions
}
class Zqsb(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(512))
publish_date = db.Column(db.DateTime, default=datetime.datetime.now)
np = db.Column(db.Integer)
pdf_url = db.Column(db.String(1024))
news = db.relationship('ZqsbNews', back_populates='master')
class User(db.Model):
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30))
password_hash = db.Column(db.String(50))
role = db.Column(db.String(15))
meals = db.relationship('Meal', backref='user', lazy='dynamic')
def __init__(self, username, password, role):
self.username = username
self.password_hash = self._set_password(password)
self.role = role
def __iter__(self):
yield 'id', self.user_id
yield 'username', self.username
yield 'role', self.role
def _set_password(self, password):
return generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class AdminMessage(db.Model):
__tablename__ = "admin_message"
__versioned__ = {}
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String, nullable=False)
show = db.Column(db.Boolean, nullable=False, default=False)
end = db.Column(db.DateTime)
created_by = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
created = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
modified = db.Column(
db.DateTime, default=datetime.utcnow, nullable=False, onupdate=datetime.utcnow
)
creator = db.relationship("User", backref="admin_messages")
@property
def is_visible(self):
return self.show and (self.end is None or self.end > datetime.utcnow())
@classmethod
def get_visible_messages(cls):
return [m for m in AdminMessage.query.all() if m.is_visible]
@classmethod
def get_all(cls):
return AdminMessage.query.order_by(AdminMessage.created).all()
@classmethod
def get_by_id(cls, id):
return AdminMessage.query.get_or_404(id)
class User(db.Model):
__tablename__ = 'user'
user_id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(20), nullable=False)
User_User_Group = db.relationship("Group", secondary='user_group')
class Content(db.Model):
__tablename__ = "content"
content_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(), nullable=False)
genre = db.Column(db.String())
year = db.Column(db.Integer)
groups = db.relationship("Group",
secondary=group_content,
backref=db.backref("contents"))
profiles = db.relationship("Profile",
secondary=unrecommend,
backref=db.backref("contents"))
def __repr__(self):
return f"<Content {self.content_id}>"
class Parent(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
child = db.relationship('Child', backref='parent', lazy=True)
def __repr__(self):
return f"Parent('{self.id}', '{self.name}')"
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Integer, default=0, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return "<Role {}>".format(self.name)
@staticmethod
def insert_roles():
roles = {
'User':
(Permission.ACTION_1 | Permission.ACTION_2 | Permission.ACTION_3,
1),
'Moderator': (Permission.ACTION_1 | Permission.ACTION_2
| Permission.ACTION_3 | Permission.ACTION_4, 0),
'Administrator': (0xff, 0)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class Inventories(db.Model):
"""dada method"""
__tablename__ = 'inventories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
buying_price = db.Column(db.Integer, nullable=False)
selling_price = db.Column(db.Integer, nullable=False)
type = db.Column(db.String(100), nullable=False)
stock = db.Column(db.Integer, nullable=False)
sales = db.relationship('Sales', backref='inv', lazy=True)
"""static method -must be in the class"""
def add_records(self):
db.session.add(self)
db.session.commit()
@classmethod
def fetch_records(cls):
return cls.query.all()
@classmethod
def fetch_a_record(cls, id1):
return cls.query.filter_by(id=id1).first()
def delete_record(self):
db.session.delete(self)
db.session.commit()
class Song(db.Model):
__table_args__ = (
db.UniqueConstraint('order', 'spotify_id', 'playlist_id'),
)
id = db.Column(db.Integer, primary_key=True)
order = db.Column(db.Integer, nullable=False)
spotify_id = db.Column(db.String(22), nullable=False)
name = db.Column(db.String(100), nullable=False)
album = db.Column(db.String(100), nullable=False)
artist = db.Column(db.String(100), nullable=False)
popularity = db.Column(db.Integer, nullable=False)
posts = db.relationship('Post', backref='song', lazy=True)
playlist_id = db.Column(db.Integer, db.ForeignKey('playlist.id'), nullable=False)
danceability = db.Column(db.Float)
energy = db.Column(db.Float)
key = db.Column(db.Integer)
mode = db.Column(db.Integer)
speechiness = db.Column(db.Float)
acousticness = db.Column(db.Float)
instrumentalness = db.Column(db.Float)
liveness = db.Column(db.Float)
valence = db.Column(db.Float)
tempo = db.Column(db.Float)
uri = db.Column(db.String(36))
time_signature = db.Column(db.Integer)
def __repr__(self):
return f"Song('{self.name}', '{self.album}')"
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
# back是反向引用,User和Post是一对多的关系，backref是表示在Post中新建一个
# 属性author，关联的是Post中的user_id外键关联的User对象。lazy属性常用的值
# 的含义，select就是访问到属性的时候，就会全部加载该属性的数据;joined则是
# 在对关联的两个表进行join操作，从而获取到所有相关的对象;
# dynamic则不一样，在访问属性的时候，并没有在内存中加载数据，而是返回一个
# query对象, 需要执行相应方法才可以获取对象，比如.all()
posts = db.relationship('Post', backref='author', lazy='dynamic')
# 设置密码
def set_password(self, password):
self.password_hash = generate_password_hash(password)
# 验证密码
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# 获取头像
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def __repr__(self):
return '<用户名:{}>'.format(self.username)
class Books(db.Model):
__tablename__ = "Books"
bookid = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
synopsis = db.Column(db.String(80))
year = db.Column(db.String(80))
authors = db.relationship("Authors",
secondary=BooksAuthors,
back_populates="books")
users = db.relationship("Users",
secondary=BooksUsers,
back_populates="books")
genres = db.relationship("Genres",
secondary=BooksGenres,
back_populates="books")
class ShiftEntry(BaseModel):
__tablename__ = "volunteer_shift_entry"
__versioned__: dict = {}
shift_id = db.Column(db.Integer,
db.ForeignKey("volunteer_shift.id"),
primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
checked_in = db.Column(db.Boolean, nullable=False, default=False)
missing_others = db.Column(db.Boolean, nullable=False, default=False)
arrived = db.Column(db.Boolean, default=False)
abandoned = db.Column(db.Boolean, default=False)
completed = db.Column(db.Boolean, default=False)
user = db.relationship("User", backref="shift_entries")
shift = db.relationship("Shift", backref="entries")
class StoreModel(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(), nullable=False)
created_at = db.Column(db.DateTime(timezone=True),
default=func.now(),
nullable=False)
items = db.relationship("ItemModel", backref="store", lazy=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def save_to_db(self) -> None:
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete()
db.session.commit()
@classmethod
def fetch_all(cls) -> "StoreModel":
return cls.query.all()
@classmethod
def fetch_by_id(cls, id) -> List["StoreModel"]:
return cls.query.filter_by(id=id).first()
@classmethod
def fetch_by_name(cls, name) -> "StoreModel":
return cls.query.filter_by(name=name).first()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
favos = db.relationship("Favo", backref='user', lazy=True)
def __repr__(self):
return "<id={self.id} name={self.name}>".format(self=self)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('Role',
secondary=user_role_link,
backref=db.backref('related_user', lazy='dynamic'))
searchphrases = db.relationship('Theme',
secondary=user_theme_link,
backref=db.backref('related_user',
lazy='dynamic'))
def __repr__(self):
return '<{}>'.format(self.username)
class DepartmentModel(db.Model):
__tablename__ = 'departments'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(45), nullable=True, unique=True)
employee = db.relationship('EmployeeModel', backref='department', lazy=True )
# this is is a static method
def create(self):
db.session.add(self)
db.session.commit()
# check if dpt exist
@classmethod
def check_dept_exist(cls,dpt_name):
record = cls.query.filter_by(name=dpt_name)
# print(cls.query.filter_by(name=dpt_name))
if record.first():
return True
else:
return False
# fecth all departments
@classmethod
def fetch_all_departments(cls):
return cls.query.all()
# fetch department by id
@classmethod
def fetch_by_id(cls,dpt_id):
return cls.query.filter_by(id=dpt_id).first()
class Point(db.Model):
__tablename__="points"
id = db.Column(db.Integer, primary_key=True)
creation_time = db.Column(db.DateTime, nullable=False)
sprint_id = db.Column(db.Integer, db.ForeignKey("sprints.id"), nullable=False)
fine_id = db.Column(db.Integer, db.ForeignKey("fines.id"), nullable=False)
giver_id = db.Column(db.Integer, db.ForeignKey("members.id"))
receiver_id = db.Column(db.Integer, db.ForeignKey("members.id"))
giver = db.relationship("Member", foreign_keys=[giver_id])
receiver = db.relationship("Member", foreign_keys=[receiver_id])
def __repr__(self):
return f"<Point {self.id}>"
class Company(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
picture = db.Column(db.String(100))
name = db.Column(db.String(100), nullable=False, unique=True)
bio = db.Column(db.Text())
specialization = db.Column(db.String(100))
username = db.Column(db.String(10), nullable=False, unique=True)
email = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(20))
role_type = db.Column(db.String(20), default="company" )
updated_at = db.Column(db.DateTime, nullable = False, default=datetime.utcnow )
created_at = db.Column(db.DateTime, nullable = False, default=datetime.utcnow )
#Relationship
comments = db.relationship('Comment', secondary=company_comment, backref='company_review')
def __init__(self, picture, name, bio, specialization, username, email, password):
self.picture = picture
self.name = name
self.bio = bio
self.specialization = specialization
self.username = username
self.email = email
self.password = password
class PurchaseTransfer(BaseModel):
"""A record of a purchase being transferred from one user to another."""
__tablename__ = "purchase_transfer"
id = db.Column(db.Integer, primary_key=True)
purchase_id = db.Column(db.Integer,
db.ForeignKey("purchase.id"),
nullable=False)
to_user_id = db.Column(db.Integer,
db.ForeignKey("user.id"),
nullable=False)
from_user_id = db.Column(db.Integer,
db.ForeignKey("user.id"),
nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
purchase = db.relationship(Purchase,
backref=db.backref("transfers", cascade="all"))
def __init__(self, purchase, to_user, from_user):
if to_user.id == from_user.id:
raise PurchaseTransferException(
'"From" and "To" users must be different.')
super().__init__(purchase=purchase,
to_user_id=to_user.id,
from_user_id=from_user.id)
def __repr__(self):
return "<Purchase Transfer: %s from %s to %s on %s>" % (
self.purchase_id,
self.from_user_id,
self.to_user_id,
self.timestamp,
)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
picture = db.Column(db.String(100))
fname = db.Column(db.String(100))
lname = db.Column(db.String(100))
bio = db.Column(db.Text())
username = db.Column(db.String(10), nullable=False, unique=True)
email = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(20))
# username = db.Column(db.String(10))
role_type = db.Column(db.String(20), default="user" )
comments = db.relationship( "Comment", backref="user", lazy=True )
updated_at = db.Column(db.DateTime, nullable = False, default=datetime.utcnow )
created_at = db.Column(db.DateTime, nullable = False, default=datetime.utcnow )
def __init__(self, picture, fname, lname, bio, username, email, password):
self.picture = picture
self.fname = fname
self.lname = lname
self.bio = bio
self.username = username
self.email = email
self.password = password
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.bio}')"
class SmartTv(db.Model):
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
barcode = db.Column(db.String)
name = db.Column(db.String)
key = db.Column(db.String, unique=True, nullable=False)
command_sensor_sensor = db.relationship("SmartTvCommandSensor",
uselist=False,
backref="smart_tv",
cascade="all, delete-orphan")
def get_tv(self, caller):
if 'SmartPhone' in str(caller):
return self
else:
print("Unauthorized!")
return None
def __repr__(self):
return "<SmartTv {}>".format(self.id)
def created(self):
return self.created_at.strftime("%d/%m/%Y %H:%M:%S")
def init_sensors(self):
if self.id is None:
db.session.add(self)
db.session.flush()
if self.command_sensor_sensor is None:
self.command_sensor_sensor = SmartTvCommandSensor(smart_tv=self)
db.session.commit()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(20), nullable=False)
lastname = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
profile_image = db.Column(db.String(20),
nullable=False,
default="39348396.png")
password = db.Column(db.String(60), nullable=False)
verify = db.Column(db.Boolean, nullable=False, default=False)
isadmin = db.Column(db.Boolean, nullable=False, default=False)
posts = db.relationship("Post", backref="author", lazy=True)
def get_verify_token(self, expiretime=3000):
s = serializer(app.config['SECRET_KEY'], expiretime)
print(self.id)
return s.dumps({"user_id": self.id}).decode("utf-8")
@staticmethod
def check_verify(token):
s = serializer(app.config['SECRET_KEY'])
try:
userid = s.loads(token)["user_id"]
except Exception as e:
print(e)
return None
return User.query.get(userid)
def __repr__(self):
return f"User('{self.email}','{self.firstname}','{self.lastname}')"
