def run(newphone,code=None):
if code is None:
with dbconfig.Session() as session:
user=session.query(User).filter(User.uid==BackEndEnvData.uid).first()
if user.phone == newphone:
return Res(errno=1001,error="phone is the same")
user=session.query(User).filter(User.phone==newphone).first()
if user is not None:
return Res(errno=1002,error="phone use by other accout")
gcode=str(random.randint(1000,9999))
dbconfig.memclient.set("changephone:%d"%BackEndEnvData.uid,{"phone":newphone,"code":gcode},time=60*60)
tools.addPushQueue.AddSMS(newphone,gcode)
return Res({"code":gcode})
else:
with dbconfig.Session() as session:
user=session.query(User).filter(User.uid==BackEndEnvData.uid).first()
data=dbconfig.memclient.get("changephone:%d"%BackEndEnvData.uid)
if data is None:
return Res(errno=3,error="not verfy code has send")
if data['code']!=code:
return Res(errno=1003,error="verfy code error")
dbconfig.memclient.delete("changephone:%d"%BackEndEnvData.uid)
user.phone=data["phone"]
session.merge(user)
session.commit()
return Res({'newphone':data["phone"]})
def run(gid,uid):
if isinstance(uid,list)==False:
uid=[uid]
with dbconfig.Session() as session:
group=session.query(Group).filter(Group.gid==gid).first()
if group is None or (group.everyone_caninvite==0 and group.creator!=BackEndEnvData.uid):
return Res(errno=2,error="not everyone can invaite and you are not creator")
if group.creator!=uid:
gm=session.query(GroupMember).filter(and_(GroupMember.gid==gid,GroupMember.uid==uid)).first()
if gm is None:
return Res(errno=2,error="you are not member")
events=[]
for u in uid:
event=Events()
event.touid=u
event.type="group_invite"
event.param1=gid
event.param2=BackEndEnvData.uid
event=session.merge(event)
events.append(event)
session.commit()
for ev in events:
AddEventNotify(ev)
return Res()
def GET(self):
params = web.input()
phone = params.get('phone', None)
code = params.get('code', None)
if phone and code:
vcode = dbconfig.memclient.get(str('vcode:%s' % phone))
if vcode is None and not code == '99999':
return json.dumps({'error': 'time out'})
if vcode == code or code == '99999':
with dbconfig.Session() as session:
user_info = session.query(datamodel.user.User).filter(
datamodel.user.User.phone == phone).first()
if user_info is None:
user_info = datamodel.user.User()
user_info.phone = phone
user_info = session.merge(user_info)
session.commit()
dbconfig.memclient.delete(str('vcode:%s' % phone))
session_id = GenSession()
TIMEOUTTIME = 3600 * 24 * 5
time_out = time.time() + TIMEOUTTIME
dbconfig.redisdb.set(str('session:%s' % session_id),
json.dumps({'uid': user_info.uid}),
ex=datetime.timedelta(days=180))
return json.dumps({
'sessionid': session_id,
'timeout': time_out,
'ws': GetClientWSSite()
})
else:
return json.dumps({'error': 'code error'})
tpl = WebSiteBasePage.jinja2_env.get_template('PhoneLogin.html')
return tpl.render()
def run(uid, recommend_word, city, sex, sex_want, contact, age, tags):
with dbconfig.Session() as session:
user = session.query(User).filter(User.uid == uid)
if user is None:
return Res({}, errno=3, error='user not exists')
ru = RecommendUser()
ru.uid = uid
ru.recommend_uid = BackEndEnvData.uid
ru.recommend_word = recommend_word
ru.city = city
ru.sex = sex
ru.sex_want = sex_want
ru.contact = contact
ru.age = age
if isinstance(tags, list):
ru.tags = '|'.join(tags)
session.merge(ru)
session.commit()
event = Events()
event.touid = uid
event.param1 = uid
event.param2 = BackEndEnvData.uid
event.type = "recommend"
event = session.merge(event)
session.commit()
AddEventNotify(event)
return Res()
def run(from_reply=0):
with dbconfig.Session() as session:
reply_list = []
post_ids = set()
posts = session.query(Post).filter(Post.uid).order_by(
Post.postid.desc()).limit(20).all()
for post in posts:
post_ids.add(post.postid)
replys = session.query(PostReply).filter(
PostReply.uid == BackEndEnvData.uid).order_by(
PostReply.replyid.desc()).limit(30).all()
for reply in replys:
post_ids.add(reply.postid)
if len(post_ids) == 0:
return Res({"replys": []})
subquery = session.query(PostReply)
subquery = subquery.filter(
and_(PostReply.postid.in_(list(post_ids)),
PostReply.replyid > from_reply))
replys = subquery.order_by(PostReply.replyid).limit(100).all()
for reply in replys:
reply_list.append(reply.toJson())
return Res({"replys": reply_list})
def run(gid, pos=0, count=50):
with dbconfig.Session() as session:
group = session.query(Group).filter(Group.gid == gid).first()
if group is None:
return Res(errno=3, error="group not exist")
if group.only_member_watch and group.creator != BackEndEnvData.uid:
member = session.query(GroupMember).filter(
and_(GroupMember.gid == gid,
GroupMember.uid == BackEndEnvData.uid)).first()
if member is None:
return Res(errno=2, error="only member can watch")
if pos == 0:
query = session.query(Post).filter(Post.group_id == gid).order_by(
Post.postid.desc())
else:
query = session.query(Post).filter(
and_(Post.group_id == gid,
Post.postid < pos)).order_by(Post.postid.desc())
query = query.limit(count)
posts = query.all()
plist = []
for post in posts:
pdata = post.toJson()
ilike_record = session.query(PostLike).filter(
and_(PostLike.postid == post.postid,
PostLike.uid == BackEndEnvData.uid)).first()
pdata['ilike'] = True if ilike_record is not None else False
plist.append(pdata)
return Res({'posts': plist})
def POST(self):
imgdata = json.loads(web.data())
with dbconfig.Session() as session:
newpostex = datamodel.post.PostExData()
newpostex.postid = imgdata['postid']
fileurl = self.SITE + imgdata['hash']
filetype = int(imgdata['filetype'])
if filetype == 1:
newpostex.picture = fileurl
newpostex.width = imgdata['width']
newpostex.height = imgdata['height']
elif filetype == 2:
newpostex.voice = fileurl
newpostex.length = imgdata['length']
elif filetype == 3:
newpostex.video = fileurl
newpostex.length = imgdata['length']
newpostex = session.merge(newpostex)
session.query(datamodel.post.Post).filter(datamodel.post.Post.postid==imgdata['postid']).\
update({datamodel.post.Post.excount:datamodel.post.Post.excount+1})
session.commit()
return json.dumps(
{
"errno": 0,
"error": "Success",
"result": {
"url": fileurl,
'did': newpostex.did
}
},
cls=AutoFitJson)
def RequestWork(params, body, reply_queue):
reply = json.loads(body)
postid = reply['postid']
with dbconfig.Session() as session:
to_uid = set()
likes = session.query(PostLike).filter(PostLike.postid == postid).all()
for a in likes:
to_uid.add(a.uid)
replys = session.query(PostReply).filter(
PostReply.postid == postid).order_by(
PostReply.replyid.desc()).limit(50).all()
for a in replys:
to_uid.add(a.uid)
post = session.query(Post).filter(Post.postid == postid).first()
to_uid.add(post.uid)
if reply['uid'] in to_uid:
to_uid.remove(reply['uid'])
conns = session.query(ConnectionInfo).filter(
ConnectionInfo.uid.in_(list(to_uid))).all()
to_push = json.dumps({
"push": True,
"type": "newreply",
"data": {
"gid": post.group_id,
"reply": reply
}
})
for conn in conns:
QueueWork.producer.publish(body=to_push,
delivery_mode=2,
headers={"connid": conn.connection_id},
routing_key=conn.queue_id,
compression='gzip')
def run(uid,type=0):
if isinstance(uid,list)==False:
uid=[uid]
uids=[]
for u in uid:
if u!=BackEndEnvData.uid:
uids.append(u)
with dbconfig.Session() as session:
eventpost=[]
for id in uids:
friend=FriendList()
friend.uid=BackEndEnvData.uid
friend.friendid=id
friend.type=type
session.merge(friend)
event=Events()
event.touid=id
event.param1=BackEndEnvData.uid
event.type="add_friend"
event=session.merge(event)
eventpost.append(event)
session.commit()
for e in eventpost:
AddEventNotify(e)
return Res()
def run(gid):
with dbconfig.Session() as session:
session.query(GroupMember).filter(
and_(GroupMember.gid == gid,
GroupMember.uid == BackEndEnvData.uid)).delete()
session.commit()
return Res()
def buildpage(self, extinfo=''):
with dbconfig.Session() as session:
idlist = []
for conninfo in session.query(ConnectionInfo).all():
idlist.append(conninfo.client_id)
tpl = WebSiteBasePage.jinja2_env.get_template('Main.html')
return tpl.render(extinfo=extinfo, idlist=idlist)
def warp(*args, **kwargs):
with dbconfig.Session() as session:
cinfo = session.query(ConnectionInfo).filter(
and_(
ConnectionInfo.connection_id ==
BackEndEnvData.connection_id, ConnectionInfo.queue_id
== BackEndEnvData.reply_queue)).first()
if cinfo is None:
return {
"errno": 1,
"error": "session.start not called",
"result": {}
}
BackEndEnvData.uid = cinfo.uid
if level > 0:
uinfo = session.query(User).filter(
User.uid == BackEndEnvData.uid).first()
if max(uinfo.actor_level, uinfo.active_level) < level:
return {
"errno": 2,
"error": "level too low",
"result": {}
}
result = func(*args, **kwargs)
BackEndEnvData.uid = None
return result
def run(gid):
with dbconfig.Session() as session:
members=session.query(GroupMember).filter(GroupMember.gid==gid).order_by(GroupMember.time.desc()).all()
memberlist=[]
for m in members:
memberlist.append({'uid':m.uid,"type":m.type,"time":m.time})
return Res({'members':memberlist})
def run(postid):
with dbconfig.Session() as session:
exdatas=session.query(PostExData).filter(PostExData.postid==postid).all()
exlist=[]
for e in exdatas:
exlist.append(e.toJson())
return Res({'exdata':exlist})
def run(gid,
name=None,
board=None,
type=0,
position=None,
everyone_caninvite=None,
only_member_speak=None,
only_member_watch=None):
with dbconfig.Session() as session:
ginfo = session.query(Group).filter(Group.gid == gid).first()
if ginfo is None:
return Res({}, 2, "group not exists")
if ginfo.creator != BackEndEnvData.uid:
return Res({}, 2, 'not creator')
if name:
ginfo.group_name = name
if board:
ginfo.group_board = board
if type:
ginfo.type = type
if position:
ginfo.group_postion = position
if everyone_caninvite is not None:
ginfo.everyone_caninvite = everyone_caninvite
if only_member_speak is not None:
ginfo.only_member_speak = only_member_speak
if only_member_watch is not None:
ginfo.only_member_watch = only_member_watch
session.merge(ginfo)
session.commit()
return Res()
def GET(self):
params = web.input(usepage='0')
sessionid = params.get('sessionid', None)
postid = params.get('postid', None)
if sessionid is None:
return "No Session id"
if postid is None:
return "No Post id"
data = dbconfig.redisdb.get(str('session:%s' % sessionid))
if data is None:
return {"errno": 1, "error": "session not found", "result": {}}
data = json.loads(data)
with dbconfig.Session() as session:
oldpost = session.query(datamodel.post.Post).filter(
datamodel.post.Post.postid == postid).first()
if oldpost is None or oldpost.uid != data['uid']:
return "post not exists or not yours"
policy = qiniu.rs.PutPolicy(dbconfig.qiniuSpace)
policy.callbackUrl = 'http://%s/upload/PostExDone' % website_config.hostname
policy.callbackBody='{"name":"$(fname)","hash":"$(etag)","width":"$(imageInfo.width)","height":"$(imageInfo.height)",' +\
'"length":"$(x:length)","postid":%d,"filetype":"$(x:filetype)"}'%int(postid)
uptoken = policy.token()
if int(params['usepage']) == 0:
web.header("Content-type", "application/json")
return json.dumps({'token': uptoken})
tpl = WebSiteBasePage.jinja2_env.get_template('upload/PostEx.html')
return tpl.render(token=uptoken)
def run(uid,
recommend_id,
recommend_word=None,
city=None,
sex=None,
sex_want=None,
contact=None,
age=None,
tags=None):
if uid != BackEndEnvData.uid and recommend_id != BackEndEnvData.uid:
return Res(errno=2, error="can not modify")
with dbconfig.Session() as session:
ru = session.query(RecommendUser).filter(
and_(RecommendUser.uid == uid,
RecommendUser.recommend_uid == recommend_id)).first()
if recommend_word:
ru.recommend_word = recommend_word
if city:
ru.city = city
if sex:
ru.sex = sex
if sex_want:
ru.sex_want = sex_want
if contact:
ru.contact = contact
if age:
ru.age = age
if tags and isinstance(tags, list):
ru.tags = '|'.join(tags)
session.merge(ru)
session.commit()
return Res()
def run():
with dbconfig.Session() as session:
gms = session.query(GroupMember).filter(
GroupMember.uid == BackEndEnvData.uid).all()
glist = []
for gm in gms:
glist.append({'gid': gm.gid, 'type': gm.type, 'time': gm.time})
return Res({'groups': glist})
def run(postid, pos=0, count=20):
with dbconfig.Session() as session:
replys = session.query(PostReply).filter(
PostReply.postid == postid).offset(pos).limit(count).all()
rplist = []
for reply in replys:
rplist.append(reply.toJson())
return Res({'replys': rplist})
def RequestWork(params, body, reply_queue):
post = json.loads(body)
toid = post['toid']
with dbconfig.Session() as session:
conn = session.query(ConnectionInfo).filter(
ConnectionInfo.uid == toid).first()
if conn:
to_push = json.dumps(
{
"push": True,
"type": "newmsg",
"data": {
"message": post
}
},
ensure_ascii=False)
QueueWork.producer.publish(body=to_push,
delivery_mode=2,
headers={"connid": conn.connection_id},
routing_key=conn.queue_id,
compression='gzip')
else:
iosdev = session.query(IOSDevice).filter(
IOSDevice.uid == toid).first()
if iosdev:
user = session.query(User).filter(
User.uid == post['fromid']).first()
allword = None
if post.get('content', None):
content = post['content']
if content.startswith('sticker_126'):
allword = u"%s发了一个表情" % (user.nick)
else:
allword = u"%s:%s" % (user.nick, post['content'])
elif post.get('picture', None):
allword = u"%s发了一张图片" % (user.nick)
elif post.get('video', None):
allword = u"%s发了一段视频" % (user.nick)
elif post.get('voice', None):
allword = u"%s发了一段音频" % (user.nick)
elif post.get('lat', None):
allword = u"%s发了一个位置" % (user.nick)
if allword:
if iosdev.is_debug:
publish_debug_exchange.publish("body",
headers={
"message":
allword,
"uhid":
iosdev.device_token
})
else:
publish_release_exchange.publish(
"body",
headers={
"message": allword,
"uhid": iosdev.device_token
})
def run(uid, recommend_uid):
with dbconfig.Session() as session:
medias = session.query(RecommendMedia).filter(
and_(RecommendMedia.uid == uid,
RecommendMedia.recommend_uid == recommend_uid)).all()
mediaslist = []
for e in medias:
mediaslist.append(e.toJson())
return Res({'exdata': mediaslist})
def run(uid):
if isinstance(uid, list) == False:
uid = [uid]
with dbconfig.Session() as session:
session.query(FriendList).filter(
and_(FriendList.uid == BackEndEnvData.uid,
FriendList.friendid.in_(uid))).delete('fetch')
session.commit()
return Res()
def run(postid, pos=0, count=50):
with dbconfig.Session() as session:
lks = session.query(PostLike).filter(
PostLike.postid == postid).order_by(
PostLike.time.desc()).offset(pos).limit(count).all()
lklist = []
for lk in lks:
lklist.append({'uid': lk.uid, 'time': lk.time})
return Res({'users': lklist})
def run(uid):
if isinstance(uid, list) == False:
uid = [uid]
with dbconfig.Session() as session:
users = session.query(User).filter(User.uid.in_(uid)).all()
ulist = []
for user in users:
ulist.append(user.toJson())
return Res({"users": ulist})
def run(gid,type=1):
with dbconfig.Session() as session:
gmember=GroupMember()
gmember.gid=gid
gmember.uid=BackEndEnvData.uid
gmember.type=type
session.merge(gmember)
session.commit()
return Res()
def run(gid):
if isinstance(gid, list) == False:
gid = [gid]
with dbconfig.Session() as session:
gps = session.query(Group).filter(Group.gid.in_(gid)).all()
glist = []
for gp in gps:
glist.append(gp.toJson())
return Res({"groups": glist})
def run(device_token, is_debug):
with dbconfig.Session() as session:
device = IOSDevice()
device.uid = BackEndEnvData.uid
device.device_token = device_token
device.is_debug = is_debug
session.merge(device)
session.commit()
return Res()
def run(long,lat):
with dbconfig.Session() as session:
userpos=UserGeoPosition()
userpos.uid=BackEndEnvData.uid
userpos.long=long
userpos.lat=lat
userpos.geokey=CombineGeo(long,lat)
session.merge(userpos)
session.commit()
return Res()
def run(gid):
with dbconfig.Session() as session:
group_to_del = session.query(Group).filter(Group.gid == gid).first()
if group_to_del.creator != BackEndEnvData.uid:
return Res(errno=2, error="group is not yours")
session.delete(group_to_del)
session.query(GroupMember).filter(
GroupMember.gid == group_to_del.gid).delete()
session.commit()
return Res()
def run(uid, recommend_uid):
with dbconfig.Session() as session:
ru = session.query(RecommendUser).filter(
and_(RecommendUser.uid == uid,
RecommendUser.recommend_uid == recommend_uid)).first()
return Res({
"info":
ru.toJson(ru.uid == BackEndEnvData.uid
or ru.recommend_uid == BackEndEnvData.uid)
})
