class UserData(db.Model, CRUDMixin, TimeMixin):
"""
collection of user data, from query used as cache, data encrpted with aes
"""
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
data = db.Column(db.String())
name = db.Column(db.String())
user_id = db.Column(db.String, db.ForeignKey('user.id'))
status = db.Column(db.String())
# client_id = StringField(default='client_')
def to_json(self):
return {
'data': self.data,
'name': self.name,
'created': self.created,
'status': self.status
}
def get_client(self):
client = redis_store.get(user_data.client_id, None)
return client
def lock_save(self, pw):
in_len = len(self.data)
pad_size = 16 - (in_len % 16)
self.data = self.data.ljust(in_len + pad_size, chr(pad_size))
if len(pw) < 16:
pw += '0' * (16 - len(pw))
iv = binascii.a2b_hex('000102030405060708090a0b0c0d0e0f')
obj = AES.new(pw, AES.MODE_CBC, iv)
self.data = str(binascii.b2a_base64(obj.encrypt(self.data)))[2:-2]
self.save()
class ConversationMember(db.Model):
id = db.Column(db.UUID(as_uuid=True),default=uuid.uuid4, primary_key=True)
conversation_id = db.Column(db.UUID, db.ForeignKey('conversation.id'))
member = db.Column(db.String, db.ForeignKey('user.id'))
avatar_URL = db.Cloumn(db.String)
status = db.Cloumn(db.String)
created = DateTimeField(default=datetime.datetime.now)
last_open =
class Conversation(db.Model):
id = db.Column(db.UUID(as_uuid=True),default=uuid.uuid4, primary_key=True)
members = ListField(ReferenceField(User, reverse_delete_rule=PULL))
messages = ListField(ReferenceField(
Message, reverse_delete_rule=mongoengine.PULL, default=lambda: []))
deleted = BooleanField(default=False)
conversation_type = StringField(
choices=('system', 'application', 'private'))
# def get_messages(count):
@property
def first_message(self):
"""Returns the first message object."""
return self.messages[0]
def get_unread(self):
return [message.to_dict() for message in self.unreadmessages]
@property
def last_message(self):
"""Returns the last message object."""
if len(self.messages):
return self.messages[-1]
else:
return None
def to_dict_abstract(self):
data = {'id': str(self.id), 'conversation': str(self.id)}
if current_user.id == self.from_user.id:
data['fromUser'] = self.from_user.to_dict()
data['toUser'] = self.to_user.to_dict()
else:
data['toUser'] = self.from_user.to_dict()
data['fromUser'] = self.to_user.to_dict()
# if len(self.unreadmessages) == 0:
data['lastMessage'] = self.last_message.to_dict(
) if self.last_message is not None else None
# else:
# data['unread'] = len(self.unreadmessages)
return data
def to_dict_detail(self):
data = {'conversation': str(self.id)}
if current_user.id == self.from_user.id:
data['fromUser'] = self.from_user.to_dict()
data['toUser'] = self.to_user.to_dict()
else:
data['toUser'] = self.from_user.to_dict()
data['fromUser'] = self.to_user.to_dict()
# data['messages'] = [message.to_dict()
# for message in self.messages[-10:]]
data['id'] = str(self.id)
data['count'] = len(self.messages)
return data
class Post(db.Model, CRUDMixin, TimeMixin):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
author_id = db.Column(db.String, db.ForeignKey('user.id'))
type = db.Column(db.String) # lost or found
tags = db.Column(db.ARRAY(db.String, dimensions=1))
title = db.Column(db.String)
category = db.Column(db.String)
content = db.Column(db.String)
img_URLs = db.Column(postgresql.ARRAY(db.String, dimensions=1))
site = db.Column(db.String)
hit = db.Column(db.Integer, default=0)
author = db.relationship('User', backref=db.backref(
'posts', lazy=True))
class Room(db.Model, CRUDMixin):
__tablename__ = 'room'
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
group = db.Column(db.String())
campus = db.Column(db.String())
building = db.Column(db.String)
floor = db.Column(db.Integer)
no = db.Column(db.Integer)
capacity = db.Column(db.Integer)
name = db.Column(db.String(80), nullable=False)
detail = db.Column(db.String(80), nullable=False)
available = db.Column(db.Boolean, default=True)
orders = db.relationship('Order',
lazy='select',
backref=db.backref('room', lazy=True))
class SocialOAuth(db.Model, CRUDMixin, TimeMixin):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
user_id = db.Column(db.String, db.ForeignKey('user.id'))
session_key = db.Column(db.String())
source = db.Column(db.String())
site = db.Column(db.String())
site_uid = db.Column(db.String())
site_uname = db.Column(db.String())
unionid = db.Column(db.String())
open_id = db.Column(db.String())
access_token = db.Column(db.String())
refresh_token = db.Column(db.String())
expire_date = db.Column(db.DateTime)
def bind_user(self, user_id):
self.user_id = user_id
self.save()
class StudentClass(db.Model, CRUDMixin, TimeMixin):
student_id = db.Column(db.String,
db.ForeignKey('undergraduate_student.id'),
primary_key=True)
class_id = db.Column(db.UUID(as_uuid=True),
db.ForeignKey('class.id'),
primary_key=True)
# grade_1 = db.Column(db.Integer, default=None)
# grade_2 = db.Column(db.Integer, default=None)
grade = db.Column(db.Float, default=None)
point = db.Column(db.Float, default=None)
_class = db.relationship("Class", back_populates="students")
student = db.relationship("UndergraduateStudent", back_populates="classes")
@property
def is_grade_register(self):
return self.grade_1 is not None and self.grade_2 is not None
class Class(db.Model, CRUDMixin, TimeMixin):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
course_id = db.Column(db.String, db.ForeignKey('course.id'), index=True)
term = db.Column(db.String, index=True)
class_id = db.Column(db.String, index=True)
teacher_id = db.Column(db.String, db.ForeignKey('teacher.id'), index=True)
teacher_raw = db.Column(db.String)
time = db.Column(db.String, index=True)
classroom = db.Column(db.String)
capacity = db.Column(db.Integer, default=0, index=True)
enroll = db.Column(db.Integer, default=0)
campus = db.Column(db.String, index=True)
q_time = db.Column(db.String)
q_place = db.Column(db.String)
credit = db.Column(db.String, index=True)
status = db.Column(db.String)
students = db.relationship('StudentClass', back_populates="_class")
__table_args__ = (db.UniqueConstraint('class_id', 'course_id', 'term'), )
class ConversationMessage(db.Model):
id = db.Column(db.UUID(as_uuid=True),default=uuid.uuid4, primary_key=True)
conversation_id = db.Column(db.UUID, db.ForeignKey('conversation.id'))
from_user_id = db.Column(db.String, db.ForeignKey('user.id'))
content = db.Column(db.String)
read = db.Column(db.Boolean,default=False)
created = DateTimeField(default=datetime.datetime.now)
# expire_from = DateTimeField(default=lambda: datetime.datetime(2100, 1, 1))
def to_dict(self):
return {
'created': str(self.created),
'sender': self.sender.card_id,
'content': self.content
}
@classmethod
def pre_save(cls, sender, document, **kwargs):
if document.sort == 'private' and document.read:
document.expire_from = datetime.datetime.now()
def __unicode__(self):
return self.content
class Order(db.Model, CRUDMixin, TimeMixin):
__tablename__ = 'room_booking_order'
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
user_id = db.Column(db.String, db.ForeignKey('user.id'))
room_id = db.Column(db.UUID, db.ForeignKey('room.id'))
contact = db.Column(db.String)
teacher = db.Column(db.String)
date = db.Column(db.DateTime)
start = db.Column(db.Integer)
end = db.Column(db.Integer)
remark = db.Column(db.String)
user = db.relationship('User', backref=db.backref('orders', lazy=True))
members = db.relationship('User',
secondary=members,
lazy='subquery',
backref=db.backref('room_booking_orders',
lazy=True))
@property
def status(self):
now = datetime.now()
timedelta = now - self.date
if timedelta.days > 0:
return '已结束'
elif timedelta.days < 0:
return '未开始'
elif timedelta.days == 0:
now = current_day_seconds()
if self.start <= now and now <= self.end:
return '已开始'
if now < self.start:
return '未开始'
if now > self.end:
return '已结束'
def save(self):
db.session.add(self)
db.session.commit()
def to_json(self):
return {
'id': self.id,
'userID': self.user_id,
'userName': self.user.name,
'roomID': self.room_id,
'room': self.room.name,
'start': self.start,
'end': self.end,
'date': self.date.timestamp(),
'status': self.status,
# 'teacher': self.teacher,
'contact': self.contact,
'remark': self.remark,
'members': [member.id for member in self.members]
}
@staticmethod
def from_json(json_post):
order = Order(
user_id=json_post['userID'],
room_id=json_post['roomID'],
date=datetime.fromtimestamp(json_post['date']),
start=json_post['start'],
end=json_post['end'],
# teacher=json_post['teacher'],
contact=json_post['contact'],
remark=json_post['remark'])
# order.save()
return order
building = db.Column(db.String)
floor = db.Column(db.Integer)
no = db.Column(db.Integer)
capacity = db.Column(db.Integer)
name = db.Column(db.String(80), nullable=False)
detail = db.Column(db.String(80), nullable=False)
available = db.Column(db.Boolean, default=True)
orders = db.relationship('Order',
lazy='select',
backref=db.backref('room', lazy=True))
members = db.Table(
'meeting_members',
db.Column('order_id',
db.UUID(as_uuid=True),
db.ForeignKey('room_booking_order.id'),
primary_key=True),
db.Column('member_id',
db.String,
db.ForeignKey('user.id'),
primary_key=True))
class Order(db.Model, CRUDMixin, TimeMixin):
__tablename__ = 'room_booking_order'
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
user_id = db.Column(db.String, db.ForeignKey('user.id'))
room_id = db.Column(db.UUID, db.ForeignKey('room.id'))
contact = db.Column(db.String)
teacher = db.Column(db.String)
class LostNFoundPost(db.Model, CRUDMixin, TimeMixin):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
author_id = db.Column(db.String, db.ForeignKey('user.id'))
type = db.Column(db.String) # lost or found
title = db.Column(db.String)
category = db.Column(db.String)
location_type = db.Column(db.String)
latitude = db.Column(db.Float)
longitude = db.Column(db.Float)
content = db.Column(db.String)
img_URLs = db.Column(postgresql.ARRAY(db.String, dimensions=1))
address = db.Column(db.String)
occurred_time = db.Column(db.DateTime, default=datetime.now)
contact = db.Column(db.String)
is_found = db.Column(db.Boolean, default=False)
site = db.Column(db.String)
hit = db.Column(db.Integer, default=0)
lighten_time = db.Column(db.DateTime, default=datetime.now)
lighten_count = db.Column(db.Integer, default=0)
author = db.relationship('User',
backref=db.backref('lost_n_found_posts',
lazy=True))
@classmethod
def from_json(cls, json_post):
post = cls(
type=json_post['type'],
author_id=json_post['authorID'],
title=json_post['title'],
content=json_post['content'],
latitude=json_post['latitude'],
longitude=json_post['longitude'],
img_URLs=json_post['imgURLs'],
address=json_post['address'],
category=json_post['category'],
site=json_post['site'],
# occurred_time = datetime.fromtimestamp(json_post['occurredTime']),
contact=json_post['contact'])
return post
def to_json(self):
return {
'id': self.id,
'type': self.type,
'authorID': self.author_id,
'authorName': self.author.username,
'authorAvatar': self.author.avatar_URL,
'category': self.category,
'title': self.title,
'content': self.content,
'latitude': self.latitude,
'longitude': self.longitude,
'imgURLs': self.img_URLs,
'address': self.address,
'occurredTime': self.occurred_time.timestamp(),
'contact': self.contact,
'isFound': self.is_found,
'site': self.site,
'lightenTime': self.lighten_time,
'lightenCount': self.lighten_count
}
def change_found_status(self, is_founded):
self.is_found = is_founded
self.save()
def lighten(self):
self.lighten_time = datetime.now()
self.lighten_count += 1
self.save()
class EventInstance(db.Model):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
class EventParticipate(db.Model):
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
