class Acti(db.Model):
__tablename__ = 'acti'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
date = db.Column(db.String(100), nullable=False)
summary = db.Column(db.String(100), nullable=False)
img = db.Column(db.String(5000), nullable=False)
def __init__(self, name, date, summery, img):
self.name = name
self.date = date
self.summary = summery
self.img = img
def __str__(self):
return '名称:%s' % (self.name)
def getDic(self):
exam = {
"name": self.name,
"date": self.date,
"summary": self.summary,
"img": self.img
}
return exam
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
openid = db.Column(db.String(100), nullable=False)
stuNo = db.Column(db.String(100))
def __init__(self, opid, code):
self.openid = opid
self.stuNo = code
class Inventory(db.Model):
id = db.Column(db.Integer, primary_key=True)
item_code = db.Column(db.String(100))
item = db.Column(db.String(100))
min_quantity = db.Column(db.Integer)
max_quantity = db.Column(db.Integer)
reorder_level = db.Column(db.Integer, default=10)
# timestamps
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# relationship
items = db.relationship('Items', backref='inventory', lazy=True)
@hybrid_property
def is_sufficient(self):
return self.reorder_level < len(
[data for data in self.items if data.current_status == 5])
@hybrid_property
def all_items(self):
return self.items
@hybrid_property
def available_items(self):
return [data for data in self.items if data.current_status == 5]
@hybrid_property
def used_items(self):
return [data for data in self.items if data.current_status == 6]
@hybrid_property
def expired_items(self):
return [data for data in self.items if data.current_status == 7]
# @hybrid_method
# def get_item(self, id):
# return [data for data in self.items if data.id == id][0]
def serialize(self):
return {
'id': self.id,
'item_code': self.item_code,
'item': self.item,
'min_quantity': self.min_quantity,
'max_quantity': self.max_quantity,
'reorder_level': self.reorder_level
}
class Tag(AuditMixin, BaseMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), nullable=False, default="Untitled Tag")
description = db.Column(db.String(140))
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', ondelete='cascade')
)
documents = db.relationship(
'Document',
backref=db.backref('tags'),
secondary=tags
)
class Document(AuditMixin, BaseMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), default="Untitled Document")
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
body = db.Column(db.String())
def user_has_access(self, user, permission='read'):
if self.user_is_owner(user):
return True
share = Share.get_share(user, self)
if share:
return getattr(share, permission)
return False
class employees(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
email = db.Column(db.String(100))
employees_logs = db.relationship('logs', backref='employee', lazy=True)
def __init__(self, name, email):
self.name = name
self.email = email
def __str__(self):
return {'id': self.id, 'name': self.name, 'email': self.email}
class Like(db.Model):
__tablename__ = 'likes'
id = db.Column(db.Integer(), primary_key=True, nullable=False)
author_id = db.Column(db.String(),
db.ForeignKey('users.username'),
nullable=False)
video_id = db.Column(db.Integer(),
db.ForeignKey('videos.id'),
nullable=False)
like = db.Column(db.Integer(), nullable=False, default=0)
dislike = db.Column(db.Integer(), nullable=False, default=0)
def __init__(self, video_id, author_id='', like=0, dislike=0):
self.video_id = video_id
self.author_id = author_id
self.like = like
self.dislike = dislike
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
db.session.commit()
def __repr__(self):
return 'Like: {}'.format(self.id)
class Services(db.Model):
id = db.Column(db.Integer, primary_key=True)
service = db.Column(db.String(50))
form = db.Column(db.JSON)
availability = db.Column(db.Integer,
default=3) # 1 for AM, 2 for PM, 3 for BOTH
# timestamps
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# relationship
appointment_service = db.relationship('Appointments',
backref='service',
lazy=True)
@hybrid_property
def form_date(self):
return json.loads(self.form)
def serialize(self):
return {
'id': self.id,
'service': self.service,
'form': self.form,
'availability': self.availability,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class CheckIn(db.Model):
__tablename__ = 'checkin'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(100), nullable=False)
time = db.Column(db.String(100), nullable=False)
stuid = db.Column(db.Integer, db.ForeignKey("student.id"))
student = db.relationship("Student", backref=db.backref("checkins"))
def __init__(self, date, time, stu):
self.date = date
self.time = time
self.student = stu
def __str__(self):
return 'id' % (self.id)
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer(), primary_key=True, nullable=False)
author_id = db.Column(db.String(),
db.ForeignKey('users.username'),
nullable=False)
video_id = db.Column(db.Integer(),
db.ForeignKey('videos.id'),
nullable=False)
content = db.Column(db.Text(), nullable=False)
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
nullable=False)
def __init__(self, video_id, content, author_id=''):
self.content = content
self.author_id = author_id
self.video_id = video_id
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
db.session.commit()
def __repr__(self):
return 'Comment: {}'.format(self.content)
class Notifications(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
notif_type = db.Column(db.String(20))
viewed = db.Column(db.Boolean, default=False)
# timestamps
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# relationship
account_id = db.Column(db.Integer,
db.ForeignKey('accounts.id'),
nullable=True)
def serialize(self):
return {
'id': self.id,
'content': self.content,
'account_id': self.account.id,
'viewed': self.viewed,
'notif_type': self.notif_type,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class HNuser(db.Model):
""" SQL database class """
username = db.Column(db.String(100), primary_key=True)
post_id = db.Column(db.Integer)
salty_rank = db.Column(db.Float, nullable=False)
salty_comments = db.Column(db.Integer, nullable=False)
# comments_total = db.Column(db.Integer, nullable=False)
def __repr__(self)
class DelAbsent(db.Model):
__tablename__ = 'delAbsent'
id = db.Column(db.Integer, primary_key=True)
period = db.Column(db.String(100), nullable=False)
date = db.Column(db.String(100), nullable=False)
def __init__(self, period, date):
self.period = period
self.date = date
def __str__(self):
return '名称:%s' % (self.d1)
def getDic(self):
delabsent = {"period": self.period,
"date": self.date,
}
class Igloo(db.Model):
__tablename__ = 'igloo'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
cost = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
patched = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
legacy_inventory = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
vanilla_inventory = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
class Comments(db.Model):
comment_id = db.Column(db.BigInteger, primary_key=True)
username = db.Column(db.String(100), db.ForeignKey('user.username'))
text = db.Column(db.String(3000))
date = db.Column(db.BigInteger)
def __repr__(self):
return f"User {self.username} -- Comment: {self.text}"
def salty_comments(self):
""" returns comments in JSON format """
return {
"comment_id" : self.comment_id,
"username" : self.username,
"text" : self.text,
"date" : self.date
""
}
class Character(db.Model):
__tablename__ = 'character'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
gift_id = db.Column(
db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
stamp_id = db.Column(
db.ForeignKey('stamp.id', ondelete='CASCADE', onupdate='CASCADE'))
class Language(db.Model):
__tablename__ = 'language'
id = db.Column(db.Integer, primary_key=True)
openid = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(100), nullable=False)
def __init__(self, name, openid):
self.name = name
self.openid = openid
def __str__(self):
return '名称:%s' % (self.name)
def getName(self):
return self.name
def getDic(self):
language = {"name": self.name, "openid": self.openid}
return language
class Classs(db.Model):
__tablename__ = 'class'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
teacher = db.Column(db.String(100), nullable=False)
teacherPhone = db.Column(db.String(100), nullable=False)
state = db.Column(db.Integer, nullable=False)
def __init__(self, name, teacher="", teacherPhone="", state=0):
self.name = name
self.teacher = teacher
self.teacherPhone = teacherPhone
self.state = state
def __str__(self):
return '班级名: %s 状态: %s' % (self.name, self.state)
def getDic(self):
return {"classname": self.name, "id": self.id}
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
openid = db.Column(db.String(100), nullable=False)
def __init__(self, openid):
self.openid = openid
def __str__(self):
return 'openid' % (self.openid)
class ExamPrep(db.Model):
__tablename__ = 'examprep'
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.String(1000), nullable=False)
def __init__(self, data):
self.data = json.dumps(data)
def __str__(self):
return 'data:%s' % (self.data)
def getDic(self):
return json.loads(self.data)
class Weather(db.Model):
__tablename__ = 'weather'
id = db.Column(db.Integer, primary_key=True)
weather = db.Column(db.String(100), nullable=False)
date = db.Column(db.String(100), nullable=False)
pm25 = db.Column(db.Float, nullable=False)
def __init__(self, weather, date, pm25):
self.weather = weather
self.date = date
self.pm25 = pm25
def __str__(self):
return '名称:%s' % (self.name)
def getDic(self):
exam = {
"name": self.name,
"date": self.date,
"summary": self.summary,
"img": self.img
}
class Exam(db.Model):
__tablename__ = 'exam'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
date = db.Column(db.String(100), nullable=False)
subject = db.Column(db.String(100), nullable=False)
def __init__(self, name, date, subject):
self.name = name
self.date = date
self.subject = subject
def __str__(self):
return '名称:%s' % (self.name)
def getDic(self):
exam = {
"name": self.name,
"date": self.date,
"subject": self.subject,
}
return exam
class Token(db.Model):
__tablename__ = 'tokens'
token = db.Column(db.String(), primary_key=True, nullable=False)
username = db.Column(db.String(32),
db.ForeignKey('users.username'),
nullable=False)
activated = db.Column(db.DateTime(timezone=True),
server_default=func.now())
def __init__(self, token, username):
self.token = token
self.username = username
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return '{}: {}'.format(self.token, self.username)
class User(BaseMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String())
last_name = db.Column(db.String())
username = db.Column(db.String(), unique=True)
email = db.Column(db.String(), unique=True)
_admin = db.Column(db.Boolean, default=False)
_active = db.Column(db.Boolean, default=True)
_password = db.Column(db.String(), nullable=False)
full_name = column_property(first_name + ' ' + last_name)
tags = db.relationship('Tag', backref='user', lazy='dynamic')
@property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = generate_password_hash(password)
def authenticate(self, password):
return check_password_hash(self._password, password)
@property
def is_admin(self):
return self._admin
@property
def is_active(self):
return self._active
def owns_document(self, document):
return document in self.documents
documents = db.relationship('Document', backref='user', lazy='dynamic')
class Absent(db.Model):
__tablename__ = 'absent'
id = db.Column(db.Integer, primary_key=True)
period = db.Column(db.Integer, nullable=False)
date = db.Column(db.String(100), nullable=False)
isCompleted = db.Column(db.Boolean, nullable=False)
className = db.Column(db.String(100), nullable=False)
stuid = db.Column(db.Integer,db.ForeignKey("student.id"))
Student = db.relationship("Student",backref=db.backref("absents"))
def __init__(self, period, date, stu, clsname):
self.period = period
self.date = date
self.Student = stu
self.isCompleted = False
self.className = clsname
def __str__(self):
return '名称:%s' % (self.d1)
def getDic(self):
absent = {"period": self.period,
"date": self.date,
}
class Roles(db.Model):
id = db.Column(db.Integer, primary_key=True)
role = db.Column(db.String(20))
# timestamps
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# relationship
accounts_roles = db.relationship('Accounts', backref='role', lazy=True)
def serialize(self):
return {
'id': self.id,
'role': self.role,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class Status(db.Model):
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.String(50))
# timestamps
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# relationship
appointment_status = db.relationship('Appointments',
backref='status',
lazy=True)
item_status = db.relationship('Items', backref='status', lazy=True)
def serialize(self):
return {
'id': self.id,
'status': self.status,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class Video(db.Model):
__tablename__ = 'videos'
id = db.Column(db.Integer(), primary_key=True, nullable=False)
author_id = db.Column(db.String(),
db.ForeignKey('users.username'),
nullable=False)
root = db.Column(db.String(), default='', nullable=False)
filename = db.Column(db.String(), default='', nullable=False)
duration = db.Column(db.String(), nullable=True)
public = db.Column(db.Boolean(), nullable=True, default=False)
title = db.Column(db.String(128), nullable=False)
text = db.Column(db.Text(), nullable=True)
views = db.Column(db.Integer(), nullable=False, default=0)
thumbnail = db.Column(db.String(), nullable=True)
hashtags = db.Column(db.String(), nullable=True)
original_author = db.Column(db.String(), nullable=True)
original_views = db.Column(db.Integer(), nullable=True)
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
nullable=False)
comments = db.relationship('Comment',
backref='user',
cascade='all,delete',
lazy=True)
voting = db.relationship('Like',
backref='votes',
cascade='all,delete',
lazy=True)
def __init__(self,
author_id,
title,
text,
duration=None,
root=None,
filename=None):
self.author_id = author_id
self.root = root
self.title = title
self.text = text
self.duration = duration
self.filename = filename
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
db.session.commit()
@staticmethod
def get_all():
return Video.query.all()
@staticmethod
def get_all_public():
return Video.query.filter_by(public=True).all()
@staticmethod
def get_all_private():
return Video.query.filter_by(public=False).all()
def __repr__(self):
return 'Video: {}'.format(self.title)
class Schedule(db.Model):
__tablename__ = 'schedule'
id = db.Column(db.Integer, primary_key=True)
mon1 = db.Column(db.String(100), nullable=False)
mon2 = db.Column(db.String(100), nullable=False)
mon3 = db.Column(db.String(100), nullable=False)
mon4 = db.Column(db.String(100), nullable=False)
mon5 = db.Column(db.String(100), nullable=False)
mon6 = db.Column(db.String(100), nullable=False)
mon7 = db.Column(db.String(100), nullable=False)
mon8 = db.Column(db.String(100), nullable=False)
mon9 = db.Column(db.String(100), nullable=False)
tue1 = db.Column(db.String(100), nullable=False)
tue2 = db.Column(db.String(100), nullable=False)
tue3 = db.Column(db.String(100), nullable=False)
tue4 = db.Column(db.String(100), nullable=False)
tue5 = db.Column(db.String(100), nullable=False)
tue6 = db.Column(db.String(100), nullable=False)
tue7 = db.Column(db.String(100), nullable=False)
tue8 = db.Column(db.String(100), nullable=False)
tue9 = db.Column(db.String(100), nullable=False)
wed1 = db.Column(db.String(100), nullable=False)
wed2 = db.Column(db.String(100), nullable=False)
wed3 = db.Column(db.String(100), nullable=False)
wed4 = db.Column(db.String(100), nullable=False)
wed5 = db.Column(db.String(100), nullable=False)
wed6 = db.Column(db.String(100), nullable=False)
wed7 = db.Column(db.String(100), nullable=False)
wed8 = db.Column(db.String(100), nullable=False)
wed9 = db.Column(db.String(100), nullable=False)
thu1 = db.Column(db.String(100), nullable=False)
thu2 = db.Column(db.String(100), nullable=False)
thu3 = db.Column(db.String(100), nullable=False)
thu4 = db.Column(db.String(100), nullable=False)
thu5 = db.Column(db.String(100), nullable=False)
thu6 = db.Column(db.String(100), nullable=False)
thu7 = db.Column(db.String(100), nullable=False)
thu8 = db.Column(db.String(100), nullable=False)
thu9 = db.Column(db.String(100), nullable=False)
fri1 = db.Column(db.String(100), nullable=False)
fri2 = db.Column(db.String(100), nullable=False)
fri3 = db.Column(db.String(100), nullable=False)
fri4 = db.Column(db.String(100), nullable=False)
fri5 = db.Column(db.String(100), nullable=False)
fri6 = db.Column(db.String(100), nullable=False)
fri7 = db.Column(db.String(100), nullable=False)
fri8 = db.Column(db.String(100), nullable=False)
fri9 = db.Column(db.String(100), nullable=False)
def construct(self):
monday = [
self.mon1, self.mon2, self.mon3, self.mon4, self.mon5, self.mon6,
self.mon7, self.mon8, self.mon9
]
tuesday = [
self.tue1, self.tue2, self.tue3, self.tue4, self.tue5, self.tue6,
self.tue7
]
wednesday = [
self.wed1, self.wed2, self.wed3, self.wed4, self.wed5, self.wed6,
self.wed7, self.wed8, self.wed9
]
thursday = [
self.thu1, self.thu2, self.thu3, self.thu4, self.thu5, self.thu6,
self.thu7, self.thu8, self.thu9
]
friday = [
self.fri1, self.fri2, self.fri3, self.fri4, self.fri5, self.fri6,
self.fri7, self.fri8, self.fri9
]
overall = [monday, tuesday, wednesday, thursday, friday]
return overall
def makeData(self, datas):
if (len(datas) < 43):
return False
print(datas)
self.mon1 = datas[0]
self.mon2 = datas[1]
self.mon3 = datas[2]
self.mon4 = datas[3]
self.mon5 = datas[4]
self.mon6 = datas[5]
self.mon7 = datas[6]
self.mon8 = datas[7]
self.mon9 = datas[8]
self.tue1 = datas[9]
self.tue2 = datas[10]
self.tue3 = datas[11]
self.tue4 = datas[12]
self.tue5 = datas[13]
self.tue6 = datas[14]
self.tue7 = datas[15]
self.tue8 = datas[16]
self.tue9 = datas[17]
self.wed1 = datas[18]
self.wed2 = datas[19]
self.wed3 = datas[20]
self.wed4 = datas[21]
self.wed5 = datas[22]
self.wed6 = datas[23]
self.wed7 = datas[24]
self.wed8 = datas[25]
self.wed9 = datas[26]
self.thu1 = datas[27]
self.thu2 = datas[28]
self.thu3 = datas[29]
self.thu4 = datas[30]
self.thu5 = datas[31]
self.thu6 = datas[32]
self.thu7 = datas[33]
self.thu8 = datas[34]
self.thu9 = datas[35]
self.fri1 = datas[36]
self.fri2 = datas[37]
self.fri3 = datas[38]
self.fri4 = datas[39]
self.fri5 = datas[40]
self.fri6 = datas[41]
self.fri7 = datas[42]
self.fri8 = datas[43]
self.fri9 = datas[44]
return True
def __init__(self, *overall):
self.makeData(overall)
def __str__(self):
return ':%s' % (self.construct())
def getDic(self):
return self.construct()
class Item(db.Model):
__tablename__ = 'item'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
type = db.Column(db.SmallInteger,
nullable=False,
server_default=db.text("1"))
cost = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
member = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
bait = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
patched = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
legacy_inventory = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
vanilla_inventory = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
epf = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
tour = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
release_date = db.Column(db.Date,
nullable=False,
server_default=db.text("now()"))
treasure = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
innocent = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
def is_color(self):
return self.type == 1
def is_head(self):
return self.type == 2
def is_face(self):
return self.type == 3
def is_neck(self):
return self.type == 4
def is_body(self):
return self.type == 5
def is_hand(self):
return self.type == 6
def is_feet(self):
return self.type == 7
def is_flag(self):
return self.type == 8
def is_photo(self):
return self.type == 9
def is_award(self):
return self.type == 10
