class LoginKey(db.Model):
id = db.Column(db.Integer, primary_key = True)
key = db.Column(db.String(64), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
endTime = db.Column(db.DateTime)
def __repr__(self):
return '<LoginKey %r>' % (self.key)
@staticmethod
def alreadyUsed(str):
if not str:
return True
used = False
for i in LoginKey.query.filter_by(key=str).all():
if i.endTime < datetime.now():
db.session.delete(i)
else:
used = True
db.session.commit()
return used
@staticmethod
def validate(str):
for i in LoginKey.query.filter_by(key=str).all():
if i.endTime < datetime.now():
db.session.delete(i)
print(i)
else:
db.session.commit()
return i.user_id
db.session.commit()
return None
class Members(db.Model):
id = db.Column(db.Integer, primary_key=True)
activity_id = db.Column(db.Integer, db.ForeignKey('activity.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
status = db.Column(db.Integer)
PATICIPATIED, PASSED, REFUSED, CREATE = range(4)
def delete(self):
print("del mem")
db.session.delete(self)
db.session.commit()
class WeixinUser(db.Model):
id = db.Column(db.Integer, primary_key = True)
openid = db.Column(db.String(64), unique = True)
nickname = db.Column(db.Text)
describe = db.Column(db.Text)
lastseen = db.Column(db.DateTime)
mode = db.Column(db.Integer)
user = db.relationship("User",backref="weixinUser",uselist = False)
def __repr__(self):
return '<Weixin %r - %r>' % (self.nickname, self.openid)
@staticmethod
def see(openid):
if not openid:
return None
wuser = WeixinUser.query.filter_by(openid=openid).first()
now = datetime.now()
if wuser:
wuser.lastseen = now
else:
wuser = WeixinUser(openid=openid, lastseen=now, mode = NORMAL)
db.session.add(wuser)
db.session.commit()
if not wuser.user:
user = User(weixin_id = wuser.id,
username = "******" % (wuser.id),
name = u"游客",
status = User.OTHERS,
is_admin = False)
db.session.add(user)
db.session.commit()
login_user(wuser.user)
return wuser.user
def setNickname(self, nickname):
user_has_samename = WeixinUser.query.filter_by(nickname=nickname).first()
if not user_has_samename or user_has_samename.id is self.id:
self.nickname = nickname
return True
else:
return False
def hasNickname(self):
if self.nickname:
return True
else:
g.user_state = 'no_nickname'
return False
def isAdmin(self):
if self.mode & ADMIN == ADMIN:
return True
return False
def isBan(self):
if self.mode & BAN == BAN:
return True
return False
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
send_time = db.Column(db.DateTime)
creator_id = db.Column(db.Integer)
receiver_id = db.Column(db.Integer)
status = db.Column(db.Integer)
NEW, HAVEREAD, DELETED = range(3)
def __init__(self, **args):
for k, v in args.items():
setattr(self, k, v)
if not args.has_key("status"):
self.status = Message.NEW
def read(self):
self.status = HAVEREAD
def delete(self):
self.status = DELETED
def getdetail(self):
details = {}
details['send_time'] = self.start_time
details['creator_name'] = User.get_by_id(self.creator_id).getname()
details['content'] = self.content
details['status'] = self.status
return details
@staticmethod
def get_by_id(id):
return Message.query.filter_by(id=id).first()
@staticmethod
def get_by_creator_id(id):
return Message.query.filter_by(creator_id=id)
@staticmethod
def get_by_receiver_id(id):
return Message.query.filter_by(receiver_id=id, status=NEW)
@staticmethod
def newMessage(content, send_time, creator_id, receiver_id):
message = Message(content=content,
send_time=send_time,
creator_id=creator_id,
receiver_id=target_id)
db.session.add(message)
db.session.commit()
class Activity(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), default="")
act_type = db.Column(db.Text, default="")
brief_desc = db.Column(db.Text, default="")
pic_url = db.Column(db.String(64), default="/image/activity/default.png")
desc = db.Column(db.Text, default="")
start_time = db.Column(db.String(64))
end_time = db.Column(db.String(64))
loc = db.Column(db.Text, default="")
status = db.Column(db.Integer)
host = db.Column(db.Text)
contact = db.Column(db.Text)
creator_id = db.Column(db.Integer)
member_maxcount = db.Column(db.Integer, default=0)
member_participatied_count = db.Column(db.Integer, default=0)
member_passed_count = db.Column(db.Integer, default=0)
member_denied_count = db.Column(db.Integer, default=0)
WAIT, FINISH = range(2)
NORMAL, FINISHED, DELETED = range(3)
members = db.relationship('Members', backref="activity", lazy="dynamic")
def __init__(self, **args):
for k, v in args.items():
setattr(self, k, v)
@staticmethod
def get_current_activity_by_name(name):
return Activity.query.filter_by(status=Activity.NORMAL).filter_by(
name=name).first()
def has_user(self, user):
if not user.is_authenticated():
return False
return self.get_member(user.id)
def get_participate_member(self):
result = []
for i in self.members.filter_by(status=Members.PATICIPATIED):
result.append({
'UID': i.user_id,
'UName': i.user.name,
'UAvator': i.user.avator
})
return result
def get_refuse_member(self):
result = []
for i in self.members.filter_by(status=Members.REFUSED):
result.append({
'UID': i.user_id,
'UName': i.user.name,
'UAvator': i.user.avator
})
return result
def get_passed_member(self):
result = []
for i in self.members.filter_by(status=Members.PASSED):
result.append({
'UID': i.user_id,
'UName': i.user.name,
'UAvator': i.user.avator
})
return result
def get_member(self, id):
return self.members.filter_by(user_id=id).first()
@staticmethod
def get_act_num():
return Activity.query.count()
@staticmethod
def search_by_name(searchname):
return Activity.query.filter(Activity.name.contains(searchname))
def create(self, user):
member = self.get_member(user.id)
if not member:
member = Members(activity_id=self.id,
user_id=user.id,
status=Members.CREATED)
db.session.add(member)
db.session.commit()
def participate(self, user):
member = self.get_member(user.id)
if not member:
member = Members(activity_id=self.id,
user_id=user.id,
status=Members.PATICIPATIED)
self.member_participatied_count += 1
db.session.add(member)
db.session.commit()
def refuse(self, user):
member = self.get_member(user.id)
if member.status == Members.PATICIPATIED:
member.status = Members.REFUSED
self.member_denied_count += 1
self.member_participatied_count -= 1
db.session.commit()
def passed(self, user):
member = self.get_member(user.id)
if member.status == Members.PATICIPATIED:
member.status = Members.PASSED
self.member_passed_count += 1
self.member_participatied_count -= 1
db.session.commit()
def getdetail(self):
details = {}
details['name'] = self.name
details['brief_desc'] = self.brief_desc
details['desc'] = self.desc
details['start_time'] = self.start_time
details['end_time'] = self.end_time
details['member_maxcount'] = self.member_maxcount
details['member_passed_count'] = self.member_passed_count
details['member_denied_count'] = self.member_denied_count
details['member_participatied_count'] = self.member_participatied_count
details['type'] = self.act_type
details['image'] = self.pic_url
details['loc'] = self.loc
details['host'] = self.host
details['contact'] = self.contact
u = User.get_by_id(self.creator_id)
details['uName'] = u.name
details['uAvator'] = u.avator
details['uID'] = self.creator_id
details['ID'] = self.id
details['member_passed'] = self.get_passed_member()
details['member_denied'] = self.get_refuse_member()
details['member_participatied'] = self.get_participate_member()
return details
def modify(self, query):
self.name = query.get('title')
self.brief_desc = query.get('brief')
self.desc = query.get('info')
self.start_time = query.get('startTime')
self.end_time = query.get('endTime')
self.member_maxcount = query.get('members')
self.loc = query.get('place')
self.host = query.get('host')
self.act_type = query.get('type')
self.pic_url = query.get('image')
db.session.commit()
@staticmethod
def get_by_id(id):
return Activity.query.filter_by(id=id).first()
@staticmethod
def get_by_creator_id(id):
return Activity.query.filter_by(creator_id=id)
@staticmethod
def get_by_joiner_id(id):
return Activity.query.filter_by()
@staticmethod
def newActivity(query):
name = query.get('title', '')
old_activity = Activity.query.filter_by(name=name).first()
if not old_activity:
act = Activity(
name=name,
brief_desc=query.get('brief', ''),
desc=query.get('info', ''),
start_time=str(query.get('startTime', '')),
end_time=str(query.get('endTime', '')),
member_maxcount=query.get('members'),
loc=query.get('place'),
host=query.get('host'),
contact=query.get('contact'),
act_type=query.get('type'),
creator_id=current_user.id,
pic_url=query.get('image'),
)
db.session.add(act)
db.session.commit()
mem = Members(activity_id=act.id,
user_id=current_user.id,
status=Members.CREATE)
db.session.add(mem)
db.session.commit()
return act
return old_activity
@staticmethod
def get_random(n):
result_list = []
act_num = Activity.get_act_num()
ran_list = range(1, act_num + 1)
ran_list2 = []
for i in ran_list:
ran_list2.append(i)
random.seed()
random.shuffle(ran_list2)
if (act_num <= n):
for i in range(act_num):
act = Activity.get_by_id(ran_list2[i])
result_list.append(act.getdetail())
else:
for i in range(n):
act = Activity.get_by_id(ran_list2[i])
result_list.append(act.getdetail())
return result_list
@staticmethod
def deleteActivity(did):
for i in Members.query.all():
db.session.delete(i)
act = Activity.get_by_id(did)
db.session.delete(act)
db.session.commit()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
weixin_id = db.Column(db.Integer, db.ForeignKey('weixin_user.id'))
loginkey_id = db.relationship("LoginKey", backref="User", uselist=False)
activities = db.relationship('Members', backref="user", lazy='dynamic')
username = db.Column(db.String(64), index=True, unique=True)
intro = db.Column(db.String(64), default="")
password = db.Column(db.String(64))
last_seen = db.Column(db.DateTime)
name = db.Column(db.String(64), default="")
email = db.Column(db.String(64), default="")
mobile = db.Column(db.String(11), default="")
avator = db.Column(db.String(64), default="/image/user/default.png")
join_time = db.Column(db.DateTime)
status = db.Column(db.Integer)
@staticmethod
def get_by_mobile(mobile):
if not mobile:
return None
return User.query.filter_by(mobile=mobile).first()
@staticmethod
def get_by_name(name):
return User.query.filter_by(status=User.MEMBER).filter_by(
name=name).first()
@staticmethod
def get_by_id(id):
print(id)
return User.query.filter_by(id=id).first()
def getname(self):
return self.name
def getdetail(self):
details = {}
details['name'] = self.name
details['email'] = self.email
details['mobile'] = self.mobile
details['introduction'] = self.intro
parti_list = []
for i in self.get_participate_activities():
parti_list.append(i.activity.getdetail())
passed_list = []
for i in self.get_passed_activities():
passed_list.append(i.activity.getdetail())
refused_list = []
for i in self.get_refused_activities():
refused_list.append(i.activity.getdetail())
created_list = []
for i in self.get_created_activities():
created_list.append(i.activity.getdetail())
details['avator'] = self.avator
details['participated'] = parti_list
details['passed'] = passed_list
details['refused'] = refused_list
details['created'] = created_list
return details
def modify(self, query):
self.name = query.get('name')
print(self.name)
self.email = query.get('email')
print(self.email)
self.mobile = query.get('mobile')
print(self.mobile)
self.intro = query.get('introduction')
print(self.intro)
db.session.commit()
def get_activities(self):
return self.activities.all()
def get_created_activities(self):
return db.session.query(Members).join(User).filter(
Members.status == Members.CREATE, User.id == self.id)
def get_participate_activities(self):
return db.session.query(Members).join(User).filter(
Members.status == Members.PATICIPATIED, User.id == self.id)
def get_refused_activities(self):
return db.session.query(Members).join(User).filter(
Members.status == Members.REFUSED, User.id == self.id)
def get_passed_activities(self):
return db.session.query(Members).join(User).filter(
Members.status == Members.PASSED, User.id == self.id)
def get_id(self):
return self.id