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 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 PenguinIglooRoom(db.Model, RoomMixin):
__tablename__ = 'penguin_igloo_room'
id = db.Column(db.Integer, primary_key=True,
server_default=db.text("nextval('\"penguin_igloo_room_id_seq\"'::regclass)"))
penguin_id = db.Column(db.ForeignKey('penguin.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
type = db.Column(db.ForeignKey('igloo.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
flooring = db.Column(db.ForeignKey('flooring.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
music = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
location = db.Column(db.ForeignKey('location.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
locked = db.Column(db.Boolean, nullable=False, server_default=db.text("true"))
competition = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
internal_id = 2000
name = 'Igloo'
member = False
max_users = 80
required_item = None
game = False
blackhole = False
spawn = False
stamp_group = None
@property
def external_id(self):
return self.penguin_id + PenguinIglooRoom.internal_id
def __init__(self, *args, **kwargs):
RoomMixin.__init__(self, *args, **kwargs)
super().__init__(*args, **kwargs)
class PenguinIgloo(db.Model):
__tablename__ = 'penguin_igloo'
penguin_id = db.Column(db.ForeignKey('penguin.id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True,
nullable=False)
igloo_id = db.Column(db.ForeignKey('igloo.id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True,
nullable=False)
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 IglooFurniture(db.Model):
__tablename__ = 'igloo_furniture'
igloo_id = db.Column(db.ForeignKey('penguin_igloo_room.id', ondelete='CASCADE', onupdate='CASCADE'),
primary_key=True, nullable=False, index=True)
furniture_id = db.Column(db.ForeignKey('furniture.id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True,
nullable=False)
x = db.Column(db.SmallInteger, primary_key=True, nullable=False, server_default=db.text("0"))
y = db.Column(db.SmallInteger, primary_key=True, nullable=False, server_default=db.text("0"))
frame = db.Column(db.SmallInteger, primary_key=True, nullable=False, server_default=db.text("0"))
rotation = db.Column(db.SmallInteger, primary_key=True, nullable=False, server_default=db.text("0"))
class BuddyRequest(db.Model):
__tablename__ = 'buddy_request'
penguin_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
requester_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
class IgnoreList(db.Model):
__tablename__ = 'ignore_list'
penguin_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
ignore_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False,
index=True)
class CharacterBuddy(db.Model):
__tablename__ = 'character_buddy'
penguin_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
character_id = db.Column(db.ForeignKey('character.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
best_buddy = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
class logs(db.Model):
id = db.Column(db.Integer, primary_key=True)
log = db.Column(db.Boolean, default=True)
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())
employee_id = db.Column(db.Integer,
db.ForeignKey('employees.id'),
nullable=False)
def __init__(self, employee_id, log):
self.employee_id = employee_id
self.log = log
def __str__(self):
return {
'id': self.id,
'log': self.log,
'created_at': self.created_at,
'updated_at': self.updated_at,
'employee_id': self.employee_id,
'name': self.employee.name,
'email': self.employee.email
}
class CfcDonation(db.Model):
__tablename__ = 'cfc_donation'
penguin_id = db.Column(db.ForeignKey('penguin.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
coins = db.Column(db.Integer, nullable=False)
charity = db.Column(db.Integer, nullable=False)
date = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
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 BuddyList(db.Model):
__tablename__ = 'buddy_list'
penguin_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
buddy_id = db.Column(db.ForeignKey('penguin.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False,
index=True)
best_buddy = db.Column(db.Boolean,
nullable=False,
server_default=db.text("false"))
class Login(db.Model):
__tablename__ = 'login'
id = db.Column(db.Integer, primary_key=True, server_default=db.text("nextval('\"login_id_seq\"'::regclass)"))
penguin_id = db.Column(db.ForeignKey('penguin.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False)
date = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
ip_hash = db.Column(db.CHAR(255), nullable=False)
minutes_played = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
class PenguinMembership(db.Model):
__tablename__ = 'penguin_membership'
penguin_id = db.Column(db.ForeignKey('penguin.id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True,
nullable=False)
start = db.Column(db.DateTime, primary_key=True, nullable=False)
expires = db.Column(db.DateTime)
start_aware = db.Column(db.Boolean, server_default=db.text("false"))
expires_aware = db.Column(db.Boolean, server_default=db.text("false"))
expired_aware = db.Column(db.Boolean, server_default=db.text("false"))
class Items(db.Model):
id = db.Column(db.Integer, primary_key=True)
expiry_date = db.Column(db.DateTime)
receive_date = db.Column(db.DateTime)
# 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
status_id = db.Column(db.Integer,
db.ForeignKey('status.id'),
nullable=True)
inventory_id = db.Column(db.Integer,
db.ForeignKey('inventory.id'),
nullable=True)
@hybrid_property
def current_status(self):
if self.expiry_date <= datetime.now() and self.status_id == 5:
return 7
else:
return self.status_id
def serialize(self):
return {
'id':
self.id,
'is_expired':
self.expiry_date >= datetime.now(),
'expiry_date':
self.expiry_date.strftime('%m/%d/%Y')
if self.expiry_date is not None else None,
'receive_date':
self.receive_date.strftime('%m/%d/%Y')
if self.receive_date is not None else None,
'status_id':
self.status.id
}
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 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 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 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 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 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 Penguin(db.Model):
__tablename__ = 'penguin'
id = db.Column(db.Integer, primary_key=True, server_default=db.text("nextval('\"penguin_id_seq\"'::regclass)"))
username = db.Column(db.String(12), nullable=False, unique=True)
nickname = db.Column(db.String(30), nullable=False)
password = db.Column(db.CHAR(60), nullable=False)
email = db.Column(db.String(255), nullable=False, index=True)
registration_date = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
active = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
safe_chat = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
last_paycheck = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
minutes_played = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
moderator = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
stealth_moderator = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
character = db.Column(db.ForeignKey('character.id', ondelete='CASCADE', onupdate='CASCADE'))
igloo = db.Column(db.ForeignKey('penguin_igloo_room.id', ondelete='CASCADE', onupdate='CASCADE'))
coins = db.Column(db.Integer, nullable=False, server_default=db.text("500"))
color = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
head = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
face = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
neck = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
body = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
hand = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
feet = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
photo = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
flag = db.Column(db.ForeignKey('item.id', ondelete='CASCADE', onupdate='CASCADE'))
permaban = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
book_modified = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
book_color = db.Column(db.SmallInteger, nullable=False, server_default=db.text("1"))
book_highlight = db.Column(db.SmallInteger, nullable=False, server_default=db.text("1"))
book_pattern = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
book_icon = db.Column(db.SmallInteger, nullable=False, server_default=db.text("1"))
agent_status = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
field_op_status = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
career_medals = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
agent_medals = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
last_field_op = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
com_message_read_date = db.Column(db.DateTime, nullable=False, server_default=db.text("now()"))
ninja_rank = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
ninja_progress = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
fire_ninja_rank = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
fire_ninja_progress = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
water_ninja_rank = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
water_ninja_progress = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
ninja_matches_won = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
fire_matches_won = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
water_matches_won = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
rainbow_adoptability = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
has_dug = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
puffle_handler = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
nuggets = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
walking = db.Column(db.ForeignKey('penguin_puffle.id', ondelete='CASCADE', onupdate='CASCADE'))
opened_playercard = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
special_wave = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
special_dance = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
special_snowball = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
map_category = db.Column(db.SmallInteger, nullable=False, server_default=db.text("0"))
status_field = db.Column(db.Integer, nullable=False, server_default=db.text("0"))
timer_active = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
timer_start = db.Column(db.Time, nullable=False, server_default=db.text("'00:00:00'::time without time zone"))
timer_end = db.Column(db.Time, nullable=False, server_default=db.text("'23:59:59'::time without time zone"))
timer_total = db.Column(db.Interval, nullable=False, server_default=db.text("'01:00:00'::interval"))
grounded = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_en = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_pt = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_fr = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_es = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_de = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
approval_ru = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_en = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_pt = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_fr = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_es = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_de = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
rejection_ru = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
sid = db.Column(db.String(255), nullable=True)
def __init__(self, *args, **kwargs):
self.inventory = None
self.permissions = None
self.attributes = None
self.igloos = None
self.igloo_rooms = None
self.furniture = None
self.flooring = None
self.locations = None
self.stamps = None
self.cards = None
self.puffles = None
self.puffle_items = None
self.buddies = None
self.buddy_requests = None
self.character_buddies = None
self.ignore = None
super().__init__(*args, **kwargs)
@lru_cache()
def safe_nickname(self, language_bitmask):
return self.nickname if self.approval & language_bitmask else "P" + str(self.id)
async def status_field_set(self, field_bitmask):
if (self.status_field & field_bitmask) == 0:
await self.update(status_field=self.status_field ^ field_bitmask).apply()
def status_field_get(self, field_bitmask):
return (self.status_field & field_bitmask) != 0
@property
@lru_cache()
def age(self):
return (datetime.now() - self.registration_date).days
@property
@lru_cache()
def approval(self):
return int(f'{self.approval_ru * 1}{self.approval_de * 1}0{self.approval_es * 1}'
f'{self.approval_fr * 1}{self.approval_pt * 1}{self.approval_en * 1}', 2)
@property
@lru_cache()
def rejection(self):
return int(f'{self.rejection_ru * 1}{self.rejection_de * 1}0{self.rejection_es * 1}'
f'{self.rejection_fr * 1}{self.rejection_pt * 1}{self.rejection_en * 1}', 2)
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')
tags = db.Table(
'tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
db.Column('document_id', db.Integer, db.ForeignKey('document.id'))
)
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',
class Share(BaseMixin, db.Model):
uid = db.Column(GUID(), primary_key=True, default=uuid4)
document_id = db.Column(
db.Integer,
db.ForeignKey('document.id', ondelete="cascade"),
nullable=False
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', ondelete='cascade'),
nullable=False
)
read = db.Column(db.Boolean, default=False, nullable=False)
write = db.Column(db.Boolean, default=False, nullable=False)
delete = db.Column(db.Boolean, default=False, nullable=False)
unique = db.UniqueConstraint()
@classmethod
def create_or_update(
cls,
user,
entity,
read=True,
write=False,
commit=True,
):
share = cls.get_share(user=user, entity=entity)
if share:
share.update_attributes({"read": read, "write": write})
else:
attrs = dict(
document_id=entity.id,
user_id=user.id,
read=read,
write=write,
)
share = Share(attrs)
share.save(commit=commit)
return share
@classmethod
def get_share(cls, user=None, entity=None):
if not user or not entity:
raise ValueError("User and entity required.")
return cls.query.filter_by(user_id=user.id) \
.filter_by(document_id=entity.id).first()
@classmethod
def shares_for_user_query(cls, user_id=None, user=None):
if user is not None:
user_id = user.id
if user_id:
return db.session.query(cls).filter_by(user_id=user_id)
return None
@classmethod
def shares_for_user(cls, user_id=None, user=None, read=None, write=None):
if not user_id:
user_id = user.id
query = cls.shares_for_user_query(user_id)
if read is not None:
query = query.filter_by(read=read)
if write is not None:
query = query.filter_by(write=write)
if query:
return query.all()
class Student(db.Model):
__tablename__ = 'student'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
stuNo = db.Column(db.String(100), nullable=False)
gender = db.Column(db.Integer, nullable=False)
daysLate = db.Column(db.Integer, nullable=False)
daysAbsent = db.Column(db.Integer, nullable=False)
memo = db.Column(db.String(100), nullable=True)
avatar = db.Column(db.String(5000), nullable=True)
engName = db.Column(db.String(100), nullable=False)
year = db.Column(db.Integer, nullable=False)
pinyin = db.Column(db.String(100), nullable=False)
#外键
classId = db.Column(db.Integer, db.ForeignKey("class.id"))
classs = db.relationship("Classs", backref=db.backref("students"))
scheduleId = db.Column(db.Integer, db.ForeignKey("schedule.id"))
schedule = db.relationship("Schedule", backref=db.backref("students"))
def __init__(self, name, stuNo, year, schedule, classs, gender, daysLate,
daysAbsent, memo, avatar, engName, pinyin):
self.name = name
self.classs = classs
self.stuNo = stuNo
self.gender = gender
self.daysLate = daysLate
self.daysAbsent = daysAbsent
self.memo = memo
self.schedule = schedule
self.avatar = avatar
self.engName = engName
self.year = year
self.pinyin = pinyin
def __str__(self):
return '姓名:%s' % (self.name)
def getSchedule(self):
type = self.scheduleId
return type
def getName(self):
return self.name
def getstuNo(self):
return self.stuNo
def getDic(self):
stuinfos = {
"name": self.name,
"code": self.stuNo,
"dayslate": self.daysLate,
"daysabsent": self.daysAbsent,
"avatar": self.avatar,
"memo": self.memo,
"class": self.classs.getDic(),
"Schedule": self.schedule.getDic(),
"engName": self.engName
}
return stuinfos
class ScheduleTemplate(db.Model):
__tablename__ = 'scheduletemplate'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(100), nullable=False)
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)
classId = db.Column(db.Integer, db.ForeignKey("class.id"))
classs = db.relationship("Classs", backref=db.backref("templates"))
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, self.tue8, self.tue9
]
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) < 45):
return False
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, name, cls, *overall):
self.code = name
self.classs = cls
self.makeData(overall)
def __str__(self):
return ':%s' % (self.construct())
class Accounts(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(100))
middle_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
gender = db.Column(db.String(10))
civil = db.Column(db.String(10))
phone = db.Column(db.String(15))
birth_date = db.Column(db.DateTime)
address = db.Column(db.String(100))
occupation = db.Column(db.String(100))
# login
email = db.Column(db.String(100))
password_hash = db.Column(db.String(128))
# timestamps
login_date = db.Column(db.DateTime, default=db.func.current_timestamp())
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
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'), nullable=True)
account_notifications = db.relationship('Notifications',
backref='account',
lazy=True)
account_appointments = db.relationship('Appointments',
backref='account',
lazy=True)
@property
def password(self):
"""
Prevent pasword from being accessed
"""
raise AttributeError('password is not a readable attribute.')
@password.setter
def password(self, password):
"""
Set password to a hashed password
"""
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
"""
Check if hashed password matches actual password
"""
return check_password_hash(self.password_hash, password)
def serialize(self):
return {
'id':
self.id,
'first_name':
self.first_name,
'middle_name':
self.middle_name,
'last_name':
self.last_name,
'gender':
self.gender,
'civil':
self.civil,
'phone':
self.phone,
'birth_date':
self.birth_date.strftime('%m/%d/%Y')
if self.birth_date is not None else None,
'email':
self.email,
'created_at':
self.created_at,
'updated_at':
self.updated_at,
'address':
self.address,
'occupation':
self.occupation,
'role_id':
self.role_id
}
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 Appointments(db.Model):
# appointment info
id = db.Column(db.Integer, primary_key=True)
details = db.Column(db.Text)
appointment_date = db.Column(db.DateTime)
assigned = db.Column(db.JSON)
meds = db.Column(db.JSON)
# medical record
record_number = db.Column(db.String(100))
record_details = db.Column(db.Text)
record_date = db.Column(db.DateTime)
record_form = db.Column(db.JSON)
next_appointments = db.Column(db.JSON)
# 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
status_id = db.Column(db.Integer,
db.ForeignKey('status.id'),
nullable=True)
service_id = db.Column(db.Integer,
db.ForeignKey('services.id'),
nullable=True)
account_id = db.Column(db.Integer,
db.ForeignKey('accounts.id'),
nullable=True)
@hybrid_property
def schedule(self):
return {
'date':
self.appointment_date.strftime('%m/%d/%Y'),
'time':
self.appointment_date.strftime('%I:%M%p') + '-' +
(self.appointment_date + timedelta(hours=1)).strftime('%I:%M%p'),
}
@hybrid_property
def prescriptions(self):
return json.loads(self.meds) if self.meds is None else json.loads(
self.meds)
@hybrid_property
def form_data(self):
return json.loads(
self.service.form) if self.record_form is None else json.loads(
self.record_form)
def serialize(self):
return {
'id':
self.id,
'details':
self.details,
'appointment_date':
self.appointment_date.strftime('%Y-%m-%dT%H:%M')
if self.appointment_date is not None else None,
'assigned':
self.assigned,
'account':
self.account.first_name + ' ' + self.account.last_name,
'record_number':
self.record_number,
'record_details':
self.record_details,
'record_form':
self.record_form,
'record_date':
self.record_date.strftime('%Y-%m-%dT%H:%M')
if self.record_date is not None else None,
'next_appointments':
self.next_appointments,
'created_at':
self.created_at,
'updated_at':
self.updated_at,
'status':
self.status.status,
'service':
self.service.service,
'status_id':
self.status_id,
'account_id':
self.account_id,
'service_id':
self.service_id,
'meds':
self.meds,
'service_form':
self.service.form
}
