def get_session_by_id(request: HttpRequest):
_param = validate_and_return(request,{
'access_token': '',
'session_id': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, "该用户已在别处登录")
queryset = models.Session.objects.filter(pk=_param['session_id'])
obj = None
for k in queryset:
obj = k
break
if obj is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR,"该会话不存在")
if models.Session.objects.get(pk=obj.id).type == 0:
session_name = models.Group.objects.get(pk=models.Session.objects.get(pk=obj.id).left_id).name
else:
if obj.left_id == user_id:
session_name = models.User.objects.get(pk=obj.right_id).nickname
else:
session_name = models.User.objects.get(pk=obj.left_id).nickname
return rS.success({
"id": obj.id,
'type': obj.type,
'title': session_name,
})
def modify(request: HttpRequest):
"""
修改活动
:param request:
:return:
"""
_param = validate_and_return(
request, {
'activity_id': '',
'title': 'nullable',
'content': 'nullable',
'place': 'nullable',
'start_time': 'nullable',
'end_time': 'nullable',
})
# permission check todo
# check what change you can notify them
_var = _param
_var.pop('activity_id')
models.Activity.objects.filter(pk=_param['activity_id']).update(**_var)
return rS.success()
def is_follow(request: HttpRequest):
"""
是否关注
:param request:
:return:
"""
_param = validate_and_return(request, {
'activity_id': '',
'require_user_id': ''
})
user = models.User.objects.get(pk=_param['require_user_id'])
activity = models.Activity.objects.get(pk=_param['group_id'])
if user is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有找到用户')
if activity is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有该活动')
mapping = models.UserAttendActivityMapping.objects.get(user=user,
activity=activity)
data = dict()
data['is_follow'] = False
if mapping.count() != 0:
data['is_follow'] = True
return rS.success(data)
def is_follow(request: HttpRequest):
_param = validate_and_return(request,{
'access_token':'',
'user_id':'',
})
a_id = UtilsController.get_id_by_token(_param['access_token'])
if a_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
b_id = _param['user_id']
p = 0
if a_id > b_id:
a_id,b_id = b_id,a_id
p = -1
obj = models.FollowMapping.objects.get(user_left_id=a_id,user_right_id=b_id)
if obj is None:
return rS.success({
'is_follow':False,
})
if p == 0:
return rS.success({
'is_follow':obj.left_to_right,
})
else:
return rS.success({
'is_follow': obj.right_to_left,
})
def dis_follow(request: HttpRequest):
_param = validate_and_return(request,{
'access_token':'',
'user_id':'',
})
a_id = UtilsController.get_id_by_token(_param['access_token'])
if a_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR,'此账号已在别处登陆')
p = 0
b_id = _param['user_id']
if a_id < b_id:
a_id,b_id = b_id,a_id
p = -1
obj = models.FollowMapping.objects.get(user_left_id=a_id,user_right_id=b_id)
if obj:
if p == 0:
obj.left_to_right = False
else:
obj.right_to_left = False
if obj.save():
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR,'取消关注失败')
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR,'没有关注此人')
def modify_enable_visited_list(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'sex': '',
'phone': '',
'status': '',
'birth': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
enable_visited_list = 0
list_dict = {
'sex': _param['sex'],
'birth': _param['birth'],
'phone': _param['phone'],
'status': _param['status'],
}
for k, v in list_dict:
enable_visited_list = enable_visited_list << 1 | v
obj = models.User.objects.get(pk=user_id)
obj.enable_visited_list = enable_visited_list
if obj.save():
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '修改失败')
def leave_comment(request: HttpRequest):
"""
活动下的评论
:param request:
:return:
"""
_param = validate_and_return(request, {
'activity_id': '',
'require_user_id': '',
'content': ''
})
user_id = _param['require_user_id']
_comment_param = dict()
_comment_param['user_id'] = user_id
_comment_param['content'] = _param['content']
_comment_param['time'] = datetime.now()
_comment = models.Comment.objects.create(**_comment_param)
if _comment is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '评论失败')
_activity = models.Activity.objects.get(pk=_param['activity_id'])
if _activity is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有该活动')
mapping = models.ActivityBelongComment.objects.create(activity=_activity,
comment=_comment)
if mapping:
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '评论失败')
def index_attend(request: HttpRequest):
"""
返回用户参加的活动列表
:param request:
:return:
"""
_param = validate_and_return(request, {
'user_id': 'int',
'page': 'int',
'size': 'int'
})
user_id = _param['user_id']
page = _param['page']
size = _param['size']
_act_attended = models.UserAttendActivityMapping.objects.filter(
user_id=user_id).order_by('-id')
count = _act_attended.count()
_act_attended_page = _act_attended[(page - 1) * size:page * size]
data_list = list()
for val in _act_attended_page:
_act = models.Activity.objects.get(pk=val.activity_id)
var = _act.to_list_dict()
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def show(request: HttpRequest):
"""
展示活动广场的活动消息
:param request:
:return:
"""
_param = validate_and_return(request, {'page': 'int', 'size': 'int'})
page = _param['page']
size = _param['size']
activities = models.Activity.objects.all()
count = activities.count()
page_activities = activities[(page - 1) * size:page * size]
data_list = list()
for val in page_activities:
var = val.to_list_dict()
data_list.append(var)
sorted_list = sorted(data_list,
key=lambda x: x['like_number'],
reverse=False) # 降序
return rS.success({'count': count, 'list': sorted_list})
def modify_password(request: HttpRequest):
_param = validate_and_return(
request, {
'access_token': '',
'ex_password': '',
'new_password': '',
'confirm_password': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
queryset = models.User.objects.filter(pk=user_id)
obj = None
for k in queryset:
obj = k
break
if obj is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, "该用户不存在")
pwd = obj.password
if _param['ex_password'] != pwd:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '密码错误')
if _param['new_password'] != _param['confirm_password']:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '两次输出的密码不一致')
obj.password = _param['new_password']
obj.save()
return rS.success()
def index_follow(request: HttpRequest):
"""
查找user follow的group
:param request:
:return:
"""
_param = validate_and_return(request, {
'user_id': 'int',
'page': 'int',
'size': 'int'
})
# 假装有个user_id
user_id = _param['user_id']
page = _param['page']
size = _param['size']
_groups_followed = models.UserFollowGroupMapping.objects.filter(
user_id=user_id).order_by('-id')
count = _groups_followed.count()
_groups_followed_page = _groups_followed[(page - 1) * size:page * size]
data_list = list()
for val in _groups_followed_page:
_group = models.Group.objects.get(pk=val.group_id)
var = _group.to_list_dict()
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def member_index(request: HttpRequest):
"""
查看指定的群组人员
:param request:
:return:
"""
_param = validate_and_return(request, {
'group_id': 'int',
'page': 'int',
'size': 'int'
})
page = _param['page']
size = _param['size']
members = models.UserFollowGroupMapping.objects.filter(
group_id=_param['group_id'])
count = members.count()
page_members = members[(page - 1) * size:page * size]
data_list = list()
for val in page_members:
var = dict()
var['user_id'] = val.user_id
var['nickname'] = val.user.nickname
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def dis_follow(request: HttpRequest):
"""
取消关注
:param request:
:return:
"""
_param = validate_and_return(request, {
'group_id': '',
'require_user_id': ''
})
user = models.User.objects.get(pk=_param['require_user_id'])
group = models.Group.objects.get(pk=_param['group_id'])
if user is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有找到用户')
if group is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有该群组')
mapping = models.UserFollowGroupMapping.objects.get(user=user, group=group)
if mapping:
mapping.delete()
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '取消关注失败')
def base_info_activity_index(request: HttpRequest):
"""
群组页面会展示的活动信息
:param request:
:return:
"""
_param = validate_and_return(request, {
'group_id': 'int',
'page': 'int',
'size': 'int'
})
page = _param['page']
size = _param['size']
group = models.Group.objects.get(pk=_param['group_id'])
activities = models.ActivityBelongGroupMapping.objects.filter(
group=group).order_by('-id')
count = activities.count()
page_activities = activities[(page - 1) * size:page * size]
data_list = list()
for val in page_activities:
var = val.activity.to_list_dict()
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def search_user(request: HttpRequest):
"""
搜索
:param request:
:return:
"""
_param = validate_and_return(request, {
'key_word': '',
'page': 'int',
'size': 'int'
})
page = _param['page']
size = _param['size']
search_results = models.User.objects.filter(
nickname__icontains=_param['key_word'], enable_searched=1)
count = search_results.count()
page_search_results = search_results[(page - 1) * size:page * size]
data_list = list()
for val in page_search_results:
var = val.to_list_dict()
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def is_follow(request: HttpRequest):
"""
是否关注
:param request:
:return:
"""
_param = validate_and_return(request, {
'group_id': '',
'require_user_id': ''
})
user = models.User.objects.get(pk=_param['require_user_id'])
group = models.Group.objects.get(pk=_param['group_id'])
if user is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有找到用户')
if group is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '没有该群组')
mapping = models.UserFollowGroupMapping.objects.filter(user=user,
group=group)
data = dict()
data['is_follow'] = False
if mapping.count() != 0:
data['is_follow'] = True
return rS.success(data)
def index_comment(request: HttpRequest):
"""
活动留下的评论
:param request:
:return:
"""
_param = validate_and_return(request, {
'activity_id': '',
'page': 'int',
'size': 'int'
})
page = _param['page']
size = _param['size']
_comment_act = models.ActivityBelongComment.objects.filter(
activity_id=_param['activity_id']).all().order_by('-id')
count = _comment_act.count()
_act_comment_page = _comment_act[(page - 1) * size:page * size]
data_list = list()
for val in _act_comment_page:
_user = models.User.objects.get(pk=val.comment.user_id)
var = val.comment.to_list_dict()
var['user_nickname'] = _user.nickname
data_list.append(var)
return rS.success({'count': count, 'list': data_list})
def modify_enable_visited_list(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'birth': '',
'phone': '',
'status': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
enable_visited_list = 0
list_dict = {
'birth': _param['birth'],
'phone': _param['phone'],
'status': _param['status'],
}
for v in list_dict:
print(v)
enable_visited_list = enable_visited_list << 1 | int(list_dict[v])
queryset = models.User.objects.filter(pk=user_id)
obj = None
for k in queryset:
obj = k
break
if obj is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此用户不存在')
obj.enable_visited_list = enable_visited_list
obj.save()
return rS.success()
def create(request: HttpRequest):
"""
创建（发布）活动
:param request:
:return:
"""
_param = validate_and_return(
request, {
'group_id': '',
'title': '',
'content': '',
'place': '',
'start_time': '',
'end_time': '',
})
group_id = _param['group_id']
_param.pop('group_id')
_activity = models.Activity.objects.create(**_param)
if _activity:
group = models.Group.objects.get(pk=group_id)
if group:
mapping = models.ActivityBelongGroupMapping.objects.create(
activity=_activity, group=group)
if mapping:
return rS.success({'id': _activity.id})
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '创建活动mapping失败')
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '群组不存在')
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '创建活动失败')
def dis_follow(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'user_id': '',
})
a_id = UtilsController.get_id_by_token(_param['access_token'])
if a_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
p = 0
b_id = _param['user_id']
if int(a_id) > int(b_id):
a_id, b_id = b_id, a_id
p = -1
print(a_id)
print(b_id)
queryset = models.FollowMapping.objects.filter(user_left_id=a_id,
user_right_id=b_id)
obj = None
for k in queryset:
obj = k
break
print(obj.to_list_dict())
if obj:
if p == 0:
obj.left_to_right = False
else:
obj.right_to_left = False
print(obj.to_list_dict())
obj.save()
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '关系不存在')
def follow(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'user_id': '',
})
a_id = UtilsController.get_id_by_token(_param['access_token'])
if a_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
p = 0
b_id = _param['user_id']
if int(a_id) > int(b_id):
a_id, b_id = b_id, a_id
p = -1
queryset = models.FollowMapping.objects.filter(user_left_id=a_id).filter(
user_right_id=b_id)
obj = None
for k in queryset:
obj = k
break
print(obj)
if obj is not None:
print(obj.to_list_dict())
if p == 0:
obj.left_to_right = True
NotificationController.create_notification(
1, b_id,
models.User.objects.get(pk=a_id).nickname + '关注了你')
else:
obj.right_to_left = True
NotificationController.create_notification(
1, a_id,
models.User.objects.get(pk=b_id).nickname + '关注了你')
obj.save()
return rS.success()
else:
if p == 0:
rs = models.FollowMapping.objects.create(user_left_id=a_id,
user_right_id=b_id,
left_to_right=True,
right_to_left=False)
NotificationController.create_notification(
1, b_id,
models.User.objects.get(pk=a_id).nickname + '关注了你')
if rs:
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '关注失败')
else:
rs = models.FollowMapping.objects.create(user_left_id=a_id,
user_right_id=b_id,
left_to_right=False,
right_to_left=True)
NotificationController.create_notification(
1, a_id,
models.User.objects.get(pk=b_id).nickname + '关注了你')
if rs:
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '关注失败')
def check_token(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail()
else:
return rS.success()
def get_information_by_id(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'user_id': '',
})
a_id = UtilsController.get_id_by_token(_param['access_token'])
if a_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
obj = models.User.objects.get(pk=_param['user_id'])
_ = obj.to_list_dict()
return rS.success(_)
def is_admin(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'group_id': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
obj = models.UserFollowGroupMapping.objects.get(user=user_id, group=_param['group_id'])
ans = ((obj.role == 1) | (obj.role == 2))
return rS.success({
'is_admin': ans
})
def base_info(request: HttpRequest):
"""
群组页面的基础信息
:param request:
:return:
"""
_param = validate_and_return(request, {'group_id': 'int'})
group = models.Group.objects.get(pk=_param['group_id'])
if group:
display_data = group.to_list_dict()
return rS.success(display_data)
def get_notification_list(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
'page': 'int',
'size': 'int',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登录')
queryset = models.Notification.objects.all().order_by("-create_time")
list_data = []
count = 0
for k in queryset:
if k.notification_type == 0:
list_data.append(k.to_list_dict())
count += 1
if k.notification_type == 1:
if k.to_id == user_id:
list_data.append(k.to_list_dict())
count += 1
if k.notification_type == 2:
if models.UserFollowGroupMapping.objects.filter(group=k.to_id,
user=user_id):
list_data.append(k.to_list_dict())
count += 1
if k.notification_type == 3:
if models.UserFollowGroupMapping.objects.filter(group=k.to_id,
user=user_id):
if models.UserFollowGroupMapping.objects.get(group=k.to_id, user=user_id).role == 1 | \
models.UserFollowGroupMapping.objects.get(group=k.to_id, user=user_id).role == 2:
list_data.append(k.to_list_dict())
count += 1
if k.notification_type == 4:
if models.UserAttendActivityMapping.objects.filter(
user=user_id, activity=k.to_id):
list_data.append(k.to_list_dict())
count += 1
page = _param['page']
size = _param['size']
return rS.success({
'count': count,
'list': list_data[(page - 1) * size:page * size],
})
def is_enable_searched(request: HttpRequest):
_param = validate_and_return(request, {
'access_token': '',
})
user_id = UtilsController.get_id_by_token(_param['access_token'])
if user_id == -1:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '此账号已在别处登陆')
obj = models.User.objects.get(pk=user_id)
return rS.success({
'is_enable_searched': obj.enable_searched,
})
def get_information_by_id(request: HttpRequest):
_param = validate_and_return(request, {
'user_id': '',
})
queryset = models.User.objects.filter(pk=_param['user_id'])
obj = None
for k in queryset:
obj = k
break
if obj is None:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '用户不存在')
_ = obj.to_list_dict()
return rS.success(_)
def modify(request: HttpRequest):
"""
修改群组
包含功能
编辑公告
编辑简介
:param request:
:return:
"""
_param = validate_and_return(
request, {
'group_id': '',
'name': 'nullable',
'notice': 'nullable',
'introduction': 'nullable'
})
group_id = _param['group_id']
# 编辑公告
if _param.get('notice', None) is not None:
# notification
create_notification(
2, group_id,
models.Group.objects.get(pk=group_id).notice + ' 更改为 ' +
_param['notice'])
Log.debug('GroupController', 'notification send')
if _param.get('name', None) is not None:
# notification
create_notification(
2, group_id,
models.Group.objects.get(pk=group_id).name + ' 更改为 ' +
_param['name'])
Log.debug('GroupController', 'notification send')
if _param.get('introduction', None) is not None:
# notification
create_notification(2, group_id, models.Group.objects.get(pk=group_id).introduction + ' 更改为 ' + \
_param['introduction'])
Log.debug('GroupController', 'notification send')
# permission check result todo
pr = True
if pr:
_param.pop('group_id')
models.Group.objects.filter(pk=group_id).update(**_param)
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '修改群组失败')
def delete(request: HttpRequest):
"""
删除群组
:param request:
:return:
"""
_param = validate_and_return(request, {'group_id': '', 'access_token': ''})
user_id = get_id_by_token(_param['access_token'])
cur_group = models.Group.objects.get(pk=_param['group_id'])
if user_id == cur_group.owner_user_id:
cur_group.delete()
return rS.success()
else:
return rS.fail(rS.ReturnResult.UNKNOWN_ERROR, '删除群组失败')
