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 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(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(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 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 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(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.creator != BackEndEnvData.uid:
return Res(errno=2, error='group not exist or you not right')
session.query(GroupMember).query(
and_(GroupMember.gid == gid, GroupMember.uid.in_(uid))).delete()
session.commit()
return Res()
def run(uid, content=None, lat=None, long=None):
if content == None and (lat == None or long == None):
return Res(errno=3, error="param error")
with dbconfig.Session() as session:
newmsg = Message()
newmsg.toid = uid
newmsg.fromid = BackEndEnvData.uid
newmsg.content = content
newmsg.lat = lat
newmsg.long = long
newmsg = session.merge(newmsg)
session.commit()
AddMessageTrans(newmsg.toJson())
return Res({'msgid': newmsg.msgid})
def run(postid):
with dbconfig.Session() as session:
post = session.query(Post).filter(Post.postid == postid).first()
if post:
if post.uid != BackEndEnvData.uid:
return Res(errno=2, error="not creator")
session.delete(post)
session.query(PostLike).filter(PostLike.postid == postid).delete()
session.query(PostReply).filter(
PostReply.postid == postid).delete()
session.commit()
else:
return Res(errno=3, error="not exist")
return Res()
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(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 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():
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 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:
session.query(FriendList).filter(
and_(FriendList.uid == BackEndEnvData.uid,
FriendList.friendid.in_(uid))).delete('fetch')
session.commit()
return Res()
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(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(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(pos=0):
with dbconfig.Session() as session:
events=session.query(Events).filter(and_(Events.touid==BackEndEnvData.uid,Events.eid>pos))\
.order_by(Events.eid.desc()).limit(50).all()
eventlist = []
for event in events:
eo = LoadEvent(event.toJson())
if eo:
eventlist.append(eo)
return Res({'events': eventlist})
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)
})
def run(gid, frompos):
with dbconfig.Session() as session:
posts = session.query(Post).filter(
and_(Post.group_id == gid,
Post.postid > frompos)).order_by(Post.postid.desc()).all()
plist = []
for post in posts:
pdata = post.toJson()
pdata['ilike'] = False
plist.append(pdata)
return Res({'posts': plist})
def run(phone_list):
with dbconfig.Session() as session:
for one in phone_list:
pb = PhoneBook()
pb.uid = BackEndEnvData.uid
pb.phone = one['phone']
pb.name = one.get('name')
session.merge(pb)
session.commit()
AddPhoneBookUpdated(BackEndEnvData.uid)
return Res()
def run(postid):
with dbconfig.Session() as session:
likerecord = session.query(PostLike).filter(
and_(PostLike.postid == postid,
PostLike.uid == BackEndEnvData.uid)).first()
if likerecord is not None:
session.delete(likerecord)
session.query(Post).filter(Post.postid == postid).update(
{Post.like: Post.like - 1})
session.commit()
return Res()
def run(nick=None):
with dbconfig.Session() as session:
query=session.query(User)
if nick:
query=query.filter(User.nick.like(nick+'%')).order_by(User.nick)
query=query.limit(20)
alluser=query.all()
user_list=[]
for u in alluser:
user_list.append(u.toJson())
return Res({"users":user_list})
