class AuditMixin(object):
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(
db.DateTime,
default=datetime.utcnow(),
onupdate=datetime.utcnow()
)
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 HistoricalData(db.Model):
"""Represents a simple OHLCV table with a symbol
"""
_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
datetime = db.Column(db.DateTime)
symbol = db.Column(db.String)
open = db.Column(db.Numeric)
high = db.Column(db.Numeric)
low = db.Column(db.Numeric)
close = db.Column(db.Numeric)
volume = db.Column(db.Integer)
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 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
}
