class Error(db.Model):
__bind_key__ = 'my_dom'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
class Express(db.Model):
__tablename__ = 'express'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
owner_id = db.Column(db.Integer, nullable=False) # 此快递的主人
taker_id = db.Column(db.Integer, nullable=True) # 此快递的代拿人
users = db.relationship('User',
secondary=express_user,
backref=db.backref('expresses')) # 此快递有关的用户
# 首页显示内容
ownername = db.Column(db.String(20), nullable=False)
starting = db.Column(db.String(20), nullable=False)
destination = db.Column(db.String(30), nullable=False)
payment = db.Column(db.Integer, nullable=False)
tips = db.Column(db.String(15), nullable=False)
# 详情页显示内容
express_id = db.Column(db.String(20), nullable=False) # 快递单号
destination_detail = db.Column(db.String(20), nullable=True) # 详细地址，选填
weight = db.Column(db.String(20), nullable=True) # 重量，选填
size = db.Column(db.String(20), nullable=True) # 大小，选填
tips_detail = db.Column(db.Text, nullable=True) # 备注，选填
# 确认代拿后显示
# 联系方式
# owner:
tele_o = db.Column(db.String(11), nullable=True)
wechat_o = db.Column(db.String(20), nullable=True)
qq_o = db.Column(db.String(20), nullable=True)
# taker:
tele_t = db.Column(db.String(11), nullable=True)
wechat_t = db.Column(db.String(20), nullable=True)
qq_t = db.Column(db.String(20), nullable=True)
# 发布、代拿、预计送达时间
time_publish = db.Column(db.String(20), nullable=False)
time_take = db.Column(db.String(20), nullable=True)
time_handover = db.Column(db.String(20), nullable=True)
# 状态：0：等待代拿；1：在路上；2：等待支付
state = db.Column(db.Integer, nullable=False)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
openid = db.Column(db.String(32), unique=True)
nickname = db.Column(db.String(32), default='-')
# 用户的性别，值为1时是男性，值为2时是女性，值为0时是未知
sex = db.Column(db.String(1), default=0)
city = db.Column(db.String(32), default='-')
country = db.Column(db.String(32), default='-')
province = db.Column(db.String(32), default='-')
language = db.Column(db.String(8), default='-')
# 用户头像，最后一个数值代表正方形头像大小（有0、46、64、96、132数值可选，0代表640*640正方形头像），
# 用户没有头像时该项为空。若用户更换头像，原有头像URL将失效。
head_img_url = db.Column(db.String(1024), default='-')
subscribe = db.Column(db.String(1), default=0)
# 用户关注时间，为时间戳。如果用户曾多次关注，则取最后关注时间
subscribe_time = db.Column(db.TIMESTAMP)
union_id = db.Column(db.String(32), default=None)
# 公众号运营者对粉丝的备注，公众号运营者可在微信公众平台用户管理界面对粉丝添加备注
remark = db.Column(db.String(32), default=None)
group_id = db.Column(db.String(32), default=None)
tagid_list = db.Column(db.PickleType)
update_time = db.Column(db.DateTime,
nullable=False,
server_default=func.now(),
server_onupdate=func.now(),
doc='更新时间')
creation_time = db.Column(db.DateTime,
nullable=False,
server_default=func.now(),
doc='创建时间')
def __repr__(self):
return '<User %r> %r(%s)' % (self.openid, self.nickname, self.remark)
@classmethod
def get(cls, id_):
return cls.query.get(id_)
@classmethod
def get_by_openid(cls, open_id):
if open_id:
return cls.query.filter_by(openid=open_id).first()
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def add_or_get(cls, **kwargs):
openid = kwargs.get('openid')
return cls.get_by_openid(openid) or cls.add(**kwargs)
@classmethod
def add(cls, openid, nickname, sex, city, country, province, language,
headimgurl, subscribe, subscribe_time, unionid, remark, groupid,
tagid_list):
"""
{u'province': u'\u5317\u4eac',
u'city': u'\u671d\u9633',
u'subscribe_time': 1467039805,
u'headimgurl': u'http://wx.qlogo.cn/mmopen/3Lqm1xHojtZbjhDFcS',
u'language': u'zh_CN', u'country': u'\u4e2d\u56fd',
u'tagid_list': [], u'remark': u'', u'sex': 1,
u'subscribe': 1, u'unionid': u'o2R60wnDWZceOBmcyAjp1tqEqLSE',
u'nickname': u'\u51af\u5f3a', u'groupid': 0}
:param openid:
:param nickname:
:param sex:
:param city:
:param country:
:param province:
:param language:
:param headimgurl:
:param subscribe:
:param subscribe_time:
:param unionid:
:param remark:
:param groupid:
:param tagid_list:
:return:
"""
instance = cls(openid=openid,
nickname=nickname,
sex=sex,
city=city,
country=country,
province=province,
language=language,
head_img_url=headimgurl,
subscribe=subscribe,
subscribe_time=subscribe_time,
union_id=unionid,
remark=remark,
group_id=groupid,
tagid_list=tagid_list)
db.session.add(instance)
db.session.commit()
return instance
@classmethod
def update(cls, openid, nickname, sex, city, country, province, language,
headimgurl, subscribe, subscribe_time, unionid, remark, groupid,
tagid_list):
instance = cls.query.filter_by(openid=openid).update(
dict(nickname=nickname,
sex=sex,
city=city,
country=country,
province=province,
language=language,
head_img_url=headimgurl,
subscribe=subscribe,
subscribe_time=subscribe_time,
union_id=unionid,
remark=remark,
group_id=groupid,
tagid_list=tagid_list))
db.session.commit()
return instance
from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
from ext import db
from config import avatar_tmpl
from .mixin import BaseMixin
friendship = db.Table(
'friends', db.Column('user_id', db.String(20), db.ForeignKey('users.id')),
db.Column('friend_id', db.String(20), db.ForeignKey('users.id')))
group_relationship = db.Table(
'group_relationship',
db.Column('group_id',
db.String(20),
db.ForeignKey('groups.id'),
nullable=False),
db.Column('user_id',
db.String(20),
db.ForeignKey('users.id'),
nullable=False))
mp_relationship = db.Table(
'mp_relationship',
db.Column('mp_id', db.String(20), db.ForeignKey('mps.id'), nullable=False),
db.Column('user_id',
db.String(20),
db.ForeignKey('users.id'),
nullable=False))
class CoreMixin(BaseMixin):
class Student(db.Model, BaseModel):
sid = db.Column(db.Integer, primary_key=True, autoincrement=True)
sname = db.Column(db.String(30))
courses = db.relationship('Course', secondary='grade', backref='students')
__tablename__ = 'student'
class Msg(db.Model):
id = db.Column(db.Integer, primary_key=True)
msg_id = db.Column(db.String(32), unique=True)
msg_type = db.Column(db.String(32), default='-')
# user openid
from_user = db.Column(db.String(32), default=0)
to_user = db.Column(db.String(32), default='-')
event = db.Column(db.String(32), default='-')
content = db.Column(db.Text, default='-')
# pic media
pic_url = db.Column(db.String(1024), default='-')
media_id = db.Column(db.String(32), default='-')
# voice
fmt = db.Column(db.String(8), default='-')
recognition = db.Column(db.Text, default='-')
# video & music
thumb_id = db.Column(db.String(64), default='-')
# location
x = db.Column(db.DECIMAL, default=0)
y = db.Column(db.DECIMAL, default=0)
scale = db.Column(db.Integer, default=0)
label = db.Column(db.String(512), default='')
update_time = db.Column(db.DateTime, nullable=False, server_default=func.now(),
server_onupdate=func.now(), doc='更新时间')
creation_time = db.Column(db.DateTime, nullable=False, doc='创建时间')
def __repr__(self):
return '<Msg %r> %s(%s)' % (self.openid, self.nickname, self.remark)
@classmethod
def get(cls, id_):
return cls.query.get(id_)
@classmethod
def get_by_msg_id(cls, msg_id):
if msg_id:
return cls.query.filter_by(openid=msg_id).first()
@classmethod
def get_all(cls):
return cls.query.order_by(-cls.creation_time).limit(100).all()
@classmethod
def add_or_get(cls, **kwargs):
msg_id = kwargs.get('msg_id')
return cls.get_by_msg_id(msg_id) or cls.add(**kwargs)
@classmethod
def add(cls, msg_id, msg_type, from_user, to_user, content, event=None, pic_url=None,
media_id=None, fmt=None, recognition=None, thumb_id=None, x=None, y=None, scale=None,
label=None, creation_time=None):
instance = cls(msg_id=msg_id, msg_type=msg_type, from_user=from_user, to_user=to_user,
event=event, content=content, pic_url=pic_url, media_id=media_id,
fmt=fmt, recognition=recognition, thumb_id=thumb_id,
x=x, y=y, scale=scale, label=label, creation_time=creation_time)
db.session.add(instance)
db.session.commit()
return instance
@classmethod
def update(cls, msg_id, **kwargs):
instance = cls.query.filter_by(openid=msg_id).update(kwargs)
db.session.commit()
return instance
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(200))
name = db.Column(db.String(20))
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
class User(UserMixin, db.Model):
# id, username, password, name, info, tasks, friends
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(1024), nullable=False, unique=True)
password = db.Column(db.String(24), nullable=False)
name = db.Column(db.String(24), nullable=False)
__verified = db.Column(db.Boolean(1), nullable=False)
__verify_code = db.Column(db.String(4))
__info = db.Column(db.String(1024))
__tasks = db.relationship('Task', backref='owner', lazy='subquery')
__friends = db.relationship(
'User', # defining the relationship, User is left side entity
secondary=friendship,
primaryjoin=(friendship.c.user_id == id),
secondaryjoin=(friendship.c.friend_id == id),
lazy='subquery')
__friendReqs = db.relationship('User',
secondary=friendReq,
primaryjoin=(friendReq.c.user_id == id),
secondaryjoin=(friendReq.c.friend_id == id),
backref=db.backref('applicant',
lazy='dynamic'),
lazy='subquery')
__ownership = db.relationship('Group', backref='owner', lazy='subquery')
__table_args__ = {"mysql_charset": "utf8"}
def __init__(self, username, password, name=None, code=None, info=''):
self.username = username
self.password = password
if name is None:
self.name = self.username
else:
self.name = name
self.__info = info
self.__verified = False
self.__verify_code = code
# def __cmp__(self, other):
# return self.name < other.name
def get_id(self):
return self.id
def get_friends(self):
return self.__friends
def get_friendreqs(self):
return self.applicant
def get_myreqs(self):
return self.__friendReqs
def get_groups(self):
return self.groups
def get_groupsReqs(self):
return self.groupsReqs
def get_ownership(self):
return self.__ownership
# rets: a json string of all tasks belonging to user
def get_tasks(self):
return [task for task in self.__tasks if task.get_publicity() != 2]
# rets: a json string of public tasks belonging to user
def get_public_tasks(self):
ret = [task for task in self.__tasks if task.get_publicity() == 0]
return ret
# rets: a dict of user's info
def get_info_map(self):
return {
'username': self.username,
'name': self.name,
'verified': self.__verified,
'info': self.__info,
}
def update(self,
username=None,
password=None,
name=None,
info=None,
code=None):
if username is not None and not User.query.filter_by(
username=username).first():
self.username = username
if password is not None:
self.password = password
if name is not None:
self.name = name
if info is not None:
self.__info = info
if code is not None:
if code == self.__verify_code:
self.__verified = True
self.__verify_code = None
return True
else:
return False
def add_friend(self, friend_id):
friend = User.query.filter_by(id=friend_id).first()
self.__friends.append(friend)
def add_friendReq(self, friend_id):
friend = User.query.filter_by(id=friend_id).first()
self.__friendReqs.append(friend)
def agree_friendReq(self, friend_id):
friend = User.query.filter_by(id=friend_id).first()
self.__friends.append(friend)
self.__friendReqs.remove(friend)
def deny_friendReq(self, friend_id):
friend = User.query.filter_by(id=friend_id).first()
self.__friendReqs.remove(friend)
def delete_friend(self, friend_id):
friend = User.query.filter_by(id=friend_id).first()
if friend in self.__friends:
self.__friends.remove(friend)
class Article_type(db.Model):
__tablename__ = 'type'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type_name = db.Column(db.String(20), nullable=False)
articles = db.relationship('Article', backref='articletype')
class Board(db.Model):
__tablename__ = "board"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
boardname = db.Column(db.String(20), nullable=False)
postnum = db.Column(db.String(200), nullable=False, default=0)
create_time = db.Column(db.DateTime, default=datetime.datetime.now)
class User(db.Model, UserMixin, BaseMixin):
__tablename__ = "users"
bio = db.Column(db.String(128), default="")
name = db.Column(db.String(128), default="")
nickname = db.Column(db.String(128), default="")
email = db.Column(db.String(191), default="")
password = db.Column(db.String(191))
website = db.Column(db.String(191), default="")
github_id = db.Column(db.String(191), default="")
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
icon_color = db.Column(db.String(7))
confirmed_at = db.Column(db.DateTime())
company = db.Column(db.String(191), default="")
avatar_id = db.Column(db.String(20), default="")
roles = db.relationship("Role",
secondary=roles_users,
backref=db.backref("users", lazy="dynamic"))
_stats = None
__table_args__ = (db.Index("idx_name", name), db.Index("idx_email", email))
def url(self):
return f"/user/{self.id}"
@property
def avatar_path(self):
avatar_id = self.avatar_id
return "" if not avatar_id else f"/static/avatars/{avatar_id}.png"
def update_avatar(self, avatar_id):
self.avatar_id = avatar_id
self.save()
def upload_avatar(self, img):
avatar_id = generate_id()
filename = UPLOAD_FOLDER / "avatars" / f"{avatar_id}.png"
if isinstance(img, str) and img.startswith("http"):
r = requests.get(img, stream=True)
if r.status_code == 200:
with open(filename, "wb") as f:
for chunk in r.iter_content(1024):
f.write(chunk)
else:
with open(filename, "wb") as f:
img.save(f)
self.update_avatar(avatar_id)
def follow(self, from_id):
ok, _ = Contact.create(to_id=self.id, from_id=from_id)
if ok:
self._stats = None
return ok
def unfollow(self, from_id):
contact = Contact.get_follow_item(from_id, self.id)
if contact:
contact.delete()
self._stats = None
return True
return False
def is_followed_by(self, user_id):
contact = Contact.get_follow_item(user_id, self.id)
return bool(contact)
@property
def n_followers(self):
return self._follow_stats[0]
@property
def n_following(self):
return self._follow_stats[1]
@property
def _follow_stats(self):
if self._stats is None:
stats = userFollowStats.get(self.id)
if not stats:
self._stats = 0, 0
else:
self._stats = stats.follower_count, stats.following_count
return self._stats
class Role(db.Model, RoleMixin):
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(191))
class Border(db.Model):
__tablename__ = 'border'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
borderName = db.Column(db.String(20), nullable=False)
postNum = db.Column(db.Integer, nullable=False, default=0)
create_time = db.Column(db.String(40), default=datetime.now)
class Group(db.Model):
# id, name, owner_id, info, tasks, members
__tablename__ = 'group'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1024), nullable=False)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
__info = db.Column(db.String(1024))
__tasks = db.relationship('Task', backref='group', lazy='subquery')
__members = db.relationship('User',
secondary=membership,
lazy='subquery',
backref=db.backref('groups', lazy=True))
__memberReqs = db.relationship('User',
secondary=memberReq,
lazy='subquery',
backref=db.backref('groupsReqs', lazy=True))
__table_args__ = {"mysql_charset": "utf8"}
def __init__(self, name, owner_id, info=''):
self.name = name
self.owner_id = owner_id
self.__info = info
user = User.query.filter_by(id=owner_id).first()
self.__members.append(user)
# def __cmp__(self, other):
# return self.name < other.name
def get_id(self):
return self.id
def add_member(self, user_id):
user = User.query.filter_by(id=user_id).first()
self.__members.append(user)
self.__memberReqs.remove(user)
def add_memberReq(self, user_id):
user = User.query.filter_by(id=user_id).first()
self.__memberReqs.append(user)
def deny_groupReq(self, user_id):
user = User.query.filter_by(id=user_id).first()
self.__memberReqs.remove(user)
def delete_member(self, user_id):
user = User.query.filter_by(id=user_id).first()
if user in self.__members:
self.__members.remove(user)
def get_members(self):
return self.__members
def get_memberReqs(self):
return self.__memberReqs
# def add_task(self, task_id):
# task = Task.query.filter_by(id=task_id).first()
# self.__tasks.append(task)
#
# def delete_task(self, task_id):
# pass #TODO
def get_tasks(self):
return self.__tasks
def update(self, name=None, owner_id=None, info=None):
if name is not None:
self.name = name
if owner_id is not None and User.query.filter_by(id=owner_id).first():
self.owner_id = owner_id
if info is not None:
self.__info = info
def get_info_map(self):
return {
'group_id': self.id,
'name': self.name,
# 'owner_id':self.owner_id,
'info': self.__info
}
class User(db.Model, DBBase):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(16), nullable=False)
password = db.Column(db.String(32), nullable=False)
email = db.Column(db.String(30), nullable=False)
udertype = db.Column(db.Integer, nullable=False)
regtime = db.Column(db.Integer, nullable=False)
lasttime = db.Column(db.Integer, nullable=False)
regip = db.Column(db.Integer, nullable=False)
picture = db.Column(db.String(255),
nullable=False,
default='public/images/avatar_blank.gif')
grade = db.Column(db.Integer, default=0)
problem = db.Column(db.String(200))
result = db.Column(db.String(200))
realname = db.Column(db.String(50))
sex = db.Column(db.Integer, default=2)
birthday = db.Column(db.String(20))
place = db.Column(db.String(50))
qq = db.Column(db.String(13))
autograph = db.Column(db.String(500))
allowlogin = db.Column(db.Integer, nullable=False)
__tablename__ = 'bbs_user'
class Task(db.Model):
# id, owner_id, title, create_time, finish_time, status, group, info
# status: 0-ongoing, 1-finished, 2-due
# publicity: 0-private, 1-public, 2-group task
# If group task, group_id is not none
__tablename__ = 'task'
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
__title = db.Column(db.String(1024), nullable=False)
__create_time = db.Column(db.DateTime, nullable=False)
finish_time = db.Column(db.DateTime, nullable=False)
__status = db.Column(db.Integer, nullable=False)
__publicity = db.Column(db.Integer, nullable=False)
__group_id = db.Column(db.Integer, db.ForeignKey('group.id'))
__info = db.Column(db.String(1024))
__table_args__ = {"mysql_charset": "utf8"}
def __init__(self,
owner_id,
title,
finish_time,
status=0,
publicity=0,
group_id=None,
info=''):
self.owner_id = owner_id
self.__title = title
self.__create_time = datetime.datetime.now()
self.finish_time = finish_time
self.__status = status
self.__publicity = publicity
if self.__publicity == 2:
self.__group_id = group_id
else:
self.__group_id = None
self.__info = info
# def __cmp__(self, other):
# return self.finish_time < other.finish_time
def get_id(self):
return self.id
def get_publicity(self):
return self.__publicity
# rets: a map includes valid=true and user_id
def get_info_map(self):
return {
'task_id': self.id,
'title': self.__title,
'create_time': str(self.__create_time),
'finish_time': str(self.finish_time),
'status': self.__status,
'publicity': self.__publicity,
'info': self.__info
}
def update(self,
owner_id=None,
title=None,
finish_time=None,
status=None,
publicity=None,
group_id=None,
info=None):
if owner_id is not None and User.query.filter_by(id=owner_id).first():
self.owner_id = owner_id
if title is not None:
self.__title = title
if finish_time is not None:
self.finish_time = finish_time
if status is not None:
self.__status = status
if publicity is not None:
self.__publicity = publicity
if self.__publicity == 2 and group_id is not None:
self.__group_id = group_id
if info is not None:
self.__info = info
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(16))
class Course(db.Model, BaseModel):
cid = db.Column(db.Integer, primary_key=True, autoincrement=True)
cname = db.Column(db.String(30))
__tablename__ = 'course'
class User(db.Model):
"""
会议的用户表和管理员表
id 编号
username 用户名
password 密码(不可见)
password_hash 储存password的hash码
email 仅一个
phone 电话号码 仅一个
company 人员所属公司
meets 关联的会议信息表
create_time 用户创建时间
msgs 关联 聊天记录
verify_password 验证密码
generate_auth_token 生成token
verify_auth_token 验证token
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
head_portrait = db.Column(db.String(128), default='file/head_portrait.jpg')
username = db.Column(db.String(25), unique=True)
password = db.Column(db.String(25))
password_hash = db.Column(db.String(225))
email = db.Column(db.String(30), unique=True)
phone = db.Column(db.String(15), unique=True)
company = db.Column(db.String(50))
meets = db.relationship('Meet', backref='users', lazy='dynamic')
create_time = db.Column(db.DateTime())
msgs = db.relationship('ChatMessage', backref='users')
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
# ---password hash
@property
def password(self):
raise AttributeError('password is not a readable attributes')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
# ---password hash
def generate_auth_token(self, expiration=6000):
s = Serializer(BaseConfig.SECRET_KEY, expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(BaseConfig.SECRET_KEY)
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
def can(self, permission):
return self.role is not None and (self.role.permissions
& permission) == permission
def is_meeter(self):
"""
判断是否为会议的创建者 permissions == 3
"""
return self.can(Permission.USER | Permission.MEETER)
def is_admin(self):
"""
判断是否系统管理员 permissions == 255
"""
return self.can(Permission.ADMINISTRATOR)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.create_time = datetime.now()
def __str__(self):
return "<User: {} id: {}>".format(self.username, self.id)
def __repr__(self):
return "<User {} id: {}>".format(self.username, self.id)
class Identity(db.Model):
#pzn_group = [1,1,1]# present group, 1 for mindfulness group, each site corresponding to female (0),male (1),unknown(2),this settings is removed since it doen't work so well
#when app is restarted several times
__tablename__ = 'Identity'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
gender = db.Column(
db.Integer) # 2 for girls, 1 for boys, and 0 for unknown...
openid = db.Column(db.String(128), unique=True)
group = db.Column(db.Integer) # randomly assigned according to gender
pzn_sessn = db.Column(db.Integer) # start from zero
max_sessn = db.Column(
db.Integer) # twelve by default, forty for superior users
train_state = db.Column(db.Integer) # 0 for not trained
created_time = db.Column(db.DateTime, nullable=False)
daily_ratn = db.Column(db.String(
1500)) # stored in formatted string, one section for each day
usr_name = db.Column(db.String(200))
name = db.Column(db.String(28))
email = db.Column(db.String(120))
session_key = db.Column(db.String(120))
fdbck = db.Column(
db.String(8000)
) # stored in formatted string, one section for each day, 10 - 30 characters for each day,also added is user_info_log
def __init__(self,
openid,
group=1,
gender=0,
pzn_sessn=1,
max_sessn=14,
putin_data='',
session_key=''):
self.session_key = session_key
self.created_time = str(datetime.now())
self.openid = openid
self.group = group
self.train_state = 0 #not trained
self.pzn_sessn = pzn_sessn
self.max_sessn = max_sessn
self.gender = gender
ptn_data = putin_data.split('<ptn_>', 4)
if len(ptn_data) == 5:
self.usr_name, self.name, self.email, self.fdbck, self.daily_ratn = ptn_data
else:
self.fdbck = putin_data
self.usr_name, self.name, self.email, self.daily_ratn = (
'Bugs', 'Is', 'Nothg', 'BtChallnge')
#deal with wrong number of <ptn_> or default parametres for data_checking
def split_putn(self,
putin_data): # since in __init__, self hasn't been created,
#so this part of code couldn't replace the similar one in __init__
ptn_data = putin_data.split('<ptn_>', 4)
if len(ptn_data) == 5:
self.usr_name, self.name, self.email, self.fdbck, self.daily_ratn = ptn_data
else:
self.fdbck = ptn_data
#print(self.fdbck)
self.usr_name, self.name, self.email, self.daily_ratn = (
'Bugs', 'Is', 'Nothg', 'BtChallnge')
#deal with wrong number of <ptn_> or default parametres for data_checking
return self
def ptn_data(self):
return "<ptn_>".join([
self.usr_name, self.name, self.email, self.fdbck, self.daily_ratn
])
def merge_ptn_data(
self,
short_dt='',
seq=-2
): #std_p could be less than zero, -2 by default to add new info to fdbck
ds1 = list(self.ptn_data().split('<ptn_>', 4))
if len(short_dt): # only insert non-empty string
ds2 = list(short_dt.split('<ptn_>'))
if len(ds2) == 5:
seq = 0 #if all data uploaded, merged from the beginning
for ii in range(0, len(ds2)):
#print('ds1: '+ds1[ii+seq] +' ds2: '+ds2[ii] +'ii: ' + str(ii) + 'seq: ' + str(seq))
ds1[ii + seq] += ds2[ii]
return self.split_putn('<ptn_>'.join(ds1))
@classmethod
def get_by_openid(cls, openid):
try:
return cls.query.filter_by(openid=openid).first()
except: # in case that database doesn't exist
#print "for in-line debugging"
return 0
@classmethod
def update_id_unique_record(cls,
openid,
uploaded_data='',
gender=0,
pzn_sessn=1,
max_sessn=14,
train_state=0,
merge_seq=-2,
session_key=0):
est_rcd = cls.get_by_openid(openid) #existing records
if est_rcd:
if not est_rcd.gender: # After Regist,the gender would be initialized with 0, and group hasn't been set at this time
try:
lst_rcd = cls.query.filter_by(
gender=gender
)[-1] #find last record and make present record in a different group
err = lst_rcd.gender
except: # in case that record doesn't exist
lst_rcd = cls(
openid='example_for_gender_' + str(gender),
gender=gender,
group=0) #Create a sample record in control group
est_rcd.group = 1 - lst_rcd.group #make it in the different group
if gender: #only updated when gender is not 0(if gender is uploaded, it won't be set zero in Main.py),but group won't be updated
est_rcd.gender = gender
est_rcd.fdbck += "<_gender_" + str(
gender) #Log the updates of gender
est_rcd = est_rcd.merge_ptn_data(
short_dt=uploaded_data,
seq=merge_seq) # by default start merging from fdbk
#est_rcd.max_sessn = max_sessn# This Updates has to be commited onto databases, change this so max_sessn could be changed back in the database
est_rcd.created_time = str(est_rcd.created_time)
if train_state:
est_rcd.train_state = train_state # only update train_state into 1, not backward
if est_rcd.train_state and est_rcd.pzn_sessn <= est_rcd.max_sessn:
t_n = datetime.now() # time of now
d_n = t_n.date() #date of now
yr, mt, dy = est_rcd.created_time[0:10].split(
'-') #update date and pzn_sessn if necessary
yr = int(yr)
mt = int(mt)
dy = int(dy)
dt = date(yr, mt, dy) #created date
if d_n > dt:
diff = int(str(d_n - dt).split(" ", 1)[0])
if diff > (
est_rcd.pzn_sessn - 1
): # not capable of missed more than one day, in codes here, multiple training will be allowed after multiple missed day
est_rcd.pzn_sessn += 1 # this if is only executed on the second day
est_rcd.train_state = 0 # reset the state to 0
if diff > est_rcd.pzn_sessn - 1: #if diff of date still >1
est_rcd.fdbck += "<_>pull_strt_from_" + est_rcd.created_time + "<_>"
est_rcd.created_time = datetime.strptime(str(dt + timedelta(days=diff-est_rcd.pzn_sessn+1)).split('.')[0]+ ' ' + \
est_rcd.created_time[11:19],'%Y-%m-%d %H:%M:%S')
est_rcd.fdbck += '<_>Log:<_>'
if session_key:
est_rcd.session_key = session_key
return (est_rcd, 0
) # set a flag for session.add to be skipped in Main.py
rst = cls(
openid=openid,
group=-1,
gender=gender,
pzn_sessn=pzn_sessn,
max_sessn=max_sessn,
putin_data=uploaded_data,
session_key=session_key
) #group set to -1 to show that it hasn't been set, and the participant thus won't be able to fetch audioInfo
return (rst, 1)
class Category(db.Model):
__tablename__ = 'category'
c_id = db.Column(db.Integer, primary_key=True)
c_name = db.Column(db.String(20, 'utf8_bin'), nullable=False, unique=True)
c_number = db.Column(db.Integer)
class PasteFile(db.Model):
__tablename__ = 'PasteFile'
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(5000), nullable=False)
filehash = db.Column(db.String(128), nullable=False, unique=True)
filemd5 = db.Column(db.String(128), nullable=False, unique=True)
uploadtime = db.Column(db.DateTime, nullable=False)
mimetype = db.Column(db.String(256), nullable=False)
size = db.Column(db.Integer, nullable=False)
def __init__(self,
filename='',
mimetype='application/octet-stream',
size=0,
filehash=None,
filemd5=None):
self.uploadtime = datetime.now()
self.mimetype = mimetype
self.size = int(size)
self.filehash = filehash if filehash else self._hash_filename(filename)
self.filename = filename if filename else self.filehash
self.filemd5 = filemd5
@staticmethod
def _hash_filename(filename):
_, _, suffix = filename.rpartition('.')
return '%s.%s' % (uuid.uuid4().hex, suffix)
@cached_property
def symlink(self):
return short_url.encode_url(self.id)
@classmethod
def get_by_symlink(cls, symlink, code=404):
id = short_url.decode_url(symlink)
return cls.query.filter_by(id=id).first() or abort(code)
@classmethod
def get_by_filehash(cls, filehash, code=404):
return cls.query.filter_by(filehash=filehash).first() or abort(code)
@classmethod
def get_by_md5(cls, filemd5):
return cls.query.filter_by(filemd5=filemd5).first()
@classmethod
def create_by_upload_file(cls, uploaded_file):
rst = cls(uploaded_file.filename, uploaded_file.mimetype, 0)
uploaded_file.save(rst.path)
with open(rst.path, 'rb') as f:
filemd5 = get_file_md5(f)
uploaded_file = cls.get_by_md5(filemd5)
if uploaded_file:
os.remove(rst.path)
return uploaded_file
filestat = os.stat(rst.path)
rst.size = filestat.st_size
rst.filemd5 = filemd5
return rst
@classmethod
def create_by_old_paste(cls, filehash):
filepath = get_file_path(filehash)
mimetype = magic.from_file(filepath, mime=True)
filestat = os.stat(filepath)
size = filestat.st_size
rst = cls(filehash, mimetype, size, filehash=filehash)
return rst
@property
def path(self):
return get_file_path(self.filehash)
def get_url(self, subtype, is_symlink=False):
hash_or_link = self.symlink if is_symlink else self.filehash
return 'http://{host}/{subtype}/{hash_or_link}'.format(
subtype=subtype, host=request.host, hash_or_link=hash_or_link)
@property
def url_i(self):
return self.get_url('i')
@property
def url_p(self):
return self.get_url('p')
@property
def url_s(self):
return self.get_url('s', is_symlink=True)
@property
def url_d(self):
return self.get_url('d')
@property
def image_size(self):
if self.is_image:
im = Image.open(self.path)
return im.size
return (0, 0)
@property
def quoteurl(self):
return quote(self.url_i)
@classmethod
def rsize(cls, old_paste, weight, height):
assert old_paste.is_image, TypeError('Unsupported Image Type.')
img = cropresize2.crop_resize(Image.open(old_paste.path),
(int(weight), int(height)))
rst = cls(old_paste.filename, old_paste.mimetype, 0)
img.save(rst.path)
filestat = os.stat(rst.path)
rst.size = filestat.st_size
return rst
@property
def is_image(self):
return self.mimetype in IMAGE_MIMES
@property
def is_audio(self):
return self.mimetype in AUDIO_MIMES
@property
def is_video(self):
return self.mimetype in VIDEO_MIMES
@property
def is_pdf(self):
return self.mimetype == 'application/pdf'
@property
def type(self):
for t in ('image', 'pdf', 'video', 'audio'):
if getattr(self, 'is_' + t):
return t
return 'binary'
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
parent_id = db.Column(db.Integer, nullable=True)
products = relationship("Announcement", backref="announcement")
want = relationship("Want", backref="want_cat")
class Link(db.Model):
__tablename__ = 'link'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20))
url = db.Column(db.String(200))
class ReasonClose(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
class Company(db.Model):
id = db.Column(db.SmallInteger, primary_key=True)
name = db.Column(db.String(50))
type = db.Column(db.Integer, default=0)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), nullable=False)
age = db.Column(db.Integer)
height = db.Column(db.String(30), default='165cm')
class User(db.Model):
__tablename__ = 'users'
__table_args__ = {'mysql_charset': 'utf8mb4'}
id = db.Column(db.Integer, primary_key=True)
sex = db.Column(db.SmallInteger, default=2)
nick_name = db.Column(db.String(60), index=True)
password = db.Column(db.String(255))
phone = db.Column(db.String(20))
email = db.Column(db.String(40))
signature = db.Column(db.String(512), default='')
province = db.Column(db.String(20), default='')
city = db.Column(db.String(20), default='')
active = db.Column(db.Boolean())
login_time = db.Column(db.Integer)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(63))
current_login_ip = db.Column(db.String(63))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users')) #, lazy='dynamic'))
groups = db.relationship('Group',
secondary=group_relationship,
backref='members')
mps = db.relationship('MP', secondary=mp_relationship, backref='users')
friends = db.relationship('User',
secondary=friendship,
primaryjoin=(friendship.c.user_id == id),
secondaryjoin=(friendship.c.friend_id == id),
lazy='dynamic')
def __repr__(self):
return '<User %r>' % self.nick_name
def to_json(self):
json_user = {
'id': self.id,
'nickname': self.nick_name,
'phone': self.phone,
'email': self.email,
'signature': self.signature,
'province': self.province,
'signature': self.signature,
'city': self.city
}
return json_user
def hash_password(self, password):
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def generate_auth_token(self, expiration=600):
s = Serializer(app.app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
def get(self, id):
return self.query.filter_by(id=id).first()
def update(self):
return session_commit()
@staticmethod
def verify_auth_token(token):
s = Serializer(app.app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
@hybrid_method
def add_friend(self, user):
if not self.is_friend(user):
self.friends.append(user)
user.friends.append(self)
return self
@hybrid_method
def del_friend(self, user):
if self.is_friend(user):
self.friends.remove(user)
user.friends.remove(self)
return self
@hybrid_method
def is_friend(self, user):
return self.friends.filter(
friendship.c.friend_id == user.id).count() > 0
@hybrid_method
def add_group(self, group):
if not self.is_in_group(group):
self.groups.append(group)
@hybrid_method
def del_group(self, group):
if self.is_in_group(group):
self.groups.remove(group)
@hybrid_method
def is_in_group(self, group):
return group in self.groups
from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
from ext import db
from config import avatar_tmpl
from .mixin import BaseMixin
friendship = db.Table('friends',
db.Column('user_id', db.String(20),
db.ForeignKey('users.id')),
db.Column('friend_id', db.String(20),
db.ForeignKey('users.id')),
mysql_charset='utf8mb4')
group_relationship = db.Table('group_relationship',
db.Column('group_id',
db.String(20),
db.ForeignKey('groups.id'),
nullable=False),
db.Column('user_id',
db.String(20),
db.ForeignKey('users.id'),
nullable=False),
mysql_charset='utf8mb4')
mp_relationship = db.Table('mp_relationship',
db.Column('mp_id',
db.String(20),
db.ForeignKey('mps.id'),
nullable=False),
db.Column('user_id',
db.String(20),
