Huis Verkennen Help
Registreer Inloggen
Kodo
/
kodo
Volgen 2
Ster 0
Vork 0

Bladeren bron
Move group user relative from group/views.py to group/groupuser_views.py

Brightcells 8 jaren geleden
bovenliggende
897377a01f
commit
0ce7c01088
3 gewijzigde bestanden met toevoegingen van 248 en 230 verwijderingen
Toon Diff Stats
  1. 6 6
      api/urls.py
  2. 240 0
      group/groupuser_views.py
  3. 2 224
      group/views.py

+ 6 - 6
api/urls.py
Bestand weergeven 

@@ -6,7 +6,7 @@ from account import views as account_views
6 6 
 from account import tourguide_views
7 7 
 from geo import views as geo_views
8 8 
 from group import views as group_views
9 
-from group import lensman_views, tourguidegroup_views, tourguidegroupuser_views
9 
+from group import groupuser_views, lensman_views, tourguidegroup_views, tourguidegroupuser_views
10 10 
 from message import views as message_views
11 11 
 from operation import views as op_views
12 12 
 from pay import views as pay_views
 
@@ -63,11 +63,11 @@ urlpatterns += [
63 63
64 64 
 # 群用户相关
65 65 
 urlpatterns += [
66 
-    url(r'^g/join$', group_views.group_join_api, name='group_join_api'),  # 成员申请加群
67 
-    url(r'^g/remove$', group_views.group_remove_api, name='group_remove_api'),  # 成员移除, 管理员主动, 群成员被动
68 
-    url(r'^g/quit$', group_views.group_quit_api, name='group_quit_api'),  # 成员退出，群成员主动
69 
-    # url(r'^g/pass$', group_views.group_pass_api, name='group_pass_api'),  # 申请通过
70 
-    # url(r'^g/refuse$', group_views.group_refuse_api, name='group_refuse_api'),  # 申请拒绝
66 
+    url(r'^g/join$', groupuser_views.group_join_api, name='group_join_api'),  # 成员申请加群
67 
+    url(r'^g/remove$', groupuser_views.group_remove_api, name='group_remove_api'),  # 成员移除, 管理员主动, 群成员被动
68 
+    url(r'^g/quit$', groupuser_views.group_quit_api, name='group_quit_api'),  # 成员退出，群成员主动
69 
+    # url(r'^g/pass$', groupuser_views.group_pass_api, name='group_pass_api'),  # 申请通过
70 
+    # url(r'^g/refuse$', groupuser_views.group_refuse_api, name='group_refuse_api'),  # 申请拒绝
71 71 
 ]
72 72
73 73 
 # 旅行团相关

+ 240 - 0
group/groupuser_views.py
Bestand weergeven 

@@ -0,0 +1,240 @@
1 
+# -*- coding: utf-8 -*-
2 
+
3 
+from __future__ import division
4 
+
5 
+from django.conf import settings
6 
+from logit import logit
7 
+from TimeConvert import TimeConvert as tc
8 
+
9 
+from account.models import UserInfo
10 
+from group.models import GroupInfo, GroupUserInfo
11 
+from utils.error.errno_utils import GroupStatusCode, GroupUserStatusCode, UserStatusCode
12 
+from utils.error.response_utils import response
13 
+from utils.group_photo_utils import get_current_photos
14 
+from utils.redis.rgroup import get_group_info, get_group_users_info, set_group_users_info
15 
+from utils.redis.rkeys import (GROUP_LAST_PHOTO_PK, GROUP_USERS_APPLYING_SET, GROUP_USERS_DELETED_SET,
16 
+                               GROUP_USERS_PASSED_SET, GROUP_USERS_QUIT_SET, GROUP_USERS_REFUSED_SET)
17 
+
18 
+
19 
+r = settings.REDIS_CACHE
20 
+
21 
+
22 
+@logit
23 
+def group_join_api(request):
24 
+    """ 申请加群 """
25 
+    group_id = request.POST.get('group_id', '')
26 
+    user_id = request.POST.get('user_id', '')
27 
+    nickname = request.POST.get('nickname', '')
28 
+
29 
+    # 用户校验
30 
+    try:
31 
+        user = UserInfo.objects.get(user_id=user_id)
32 
+    except UserInfo.DoesNotExist:
33 
+        return response(UserStatusCode.USER_NOT_FOUND)
34 
+
35 
+    # 群组校验
36 
+    try:
37 
+        group = GroupInfo.objects.get(group_id=group_id)
38 
+    except GroupInfo.DoesNotExist:
39 
+        return response(GroupStatusCode.GROUP_NOT_FOUND)
40 
+
41 
+    # 群组锁定校验
42 
+    if group.group_lock:
43 
+        return response(GroupStatusCode.GROUP_HAS_LOCKED)
44 
+
45 
+    # 群组用户记录创建，若记录不存在，则创建，若记录已存在，则更新
46 
+    group_user, created = GroupUserInfo.objects.get_or_create(
47 
+        group_id=group_id,
48 
+        user_id=user_id,
49 
+    )
50 
+    if group_user.user_status != GroupUserInfo.PASSED:
51 
+        group_user.current_id = -1 if group.group_from == GroupInfo.SESSION_GROUP else int(r.get(GROUP_LAST_PHOTO_PK % group_id) or -1)
52 
+        group_user.nickname = nickname or user.final_nickname
53 
+        group_user.avatar = user.avatar
54 
+        # group_user.admin = False  # Admin Field Default False, Should Not Assign
55 
+        group_user.user_status = GroupUserInfo.PASSED
56 
+        group_user.passed_at = tc.utc_datetime()
57 
+        group_user.save()
58 
+
59 
+    # Redis 群组用户数据缓存
60 
+    set_group_users_info(group)
61 
+
62 
+    # Redis 群组通过集合缓存
63 
+    r.srem(GROUP_USERS_REFUSED_SET % group_id, user_id)
64 
+    r.srem(GROUP_USERS_DELETED_SET % group_id, user_id)
65 
+    r.srem(GROUP_USERS_QUIT_SET % group_id, user_id)
66 
+    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)
67 
+
68 
+    curinfo = get_current_photos(group_id, user_id, group_user.current_id)
69 
+
70 
+    return response(200, 'Apply Success', u'申请成功', {
71 
+        'current_id': curinfo.get('current_id', ''),
72 
+        'photos': curinfo.get('photos', ''),
73 
+        'group_id': group_id,
74 
+        'group': get_group_info(group_id),
75 
+        'user_id': user_id,
76 
+        'users': get_group_users_info(group_id, user_id),
77 
+    })
78 
+
79 
+
80 
+@logit
81 
+def group_remove_api(request):
82 
+    """ 成员移除 """
83 
+    group_id = request.POST.get('group_id', '')
84 
+    admin_id = request.POST.get('admin_id', '')
85 
+    user_id = request.POST.get('user_id', '')
86 
+
87 
+    # 群组校验
88 
+    try:
89 
+        group = GroupInfo.objects.get(group_id=group_id)
90 
+    except GroupInfo.DoesNotExist:
91 
+        return response(GroupStatusCode.GROUP_NOT_FOUND)
92 
+
93 
+    # 权限校验
94 
+    if group.admin_id != admin_id or group.admin_id == user_id:  # 管理员也不允许将自己移除
95 
+        return response(GroupStatusCode.NO_REMOVE_PERMISSION)
96 
+
97 
+    # 群组用户校验
98 
+    try:
99 
+        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
100 
+    except GroupUserInfo.DoesNotExist:
101 
+        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)
102 
+
103 
+    # 群组用户移除
104 
+    group_user.user_status = GroupUserInfo.DELETED
105 
+    group_user.deleted_at = tc.utc_datetime()
106 
+    group_user.save()
107 
+
108 
+    # Redis 群组数据缓存更新
109 
+    group_users = set_group_users_info(group)
110 
+
111 
+    # Redis 群组删除集合缓存
112 
+    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
113 
+    r.sadd(GROUP_USERS_DELETED_SET % group_id, user_id)
114 
+
115 
+    return response(200, 'Remove Success', u'用户移除成功', {
116 
+        'group_id': group_id,
117 
+        'users': group_users,
118 
+    })
119 
+
120 
+
121 
+@logit
122 
+def group_quit_api(request):
123 
+    """ 成员退出 """
124 
+    group_id = request.POST.get('group_id', '')
125 
+    user_id = request.POST.get('user_id', '')
126 
+
127 
+    # 群组校验
128 
+    try:
129 
+        group = GroupInfo.objects.get(group_id=group_id)
130 
+    except GroupInfo.DoesNotExist:
131 
+        return response(GroupStatusCode.GROUP_NOT_FOUND)
132 
+
133 
+    # 权限校验
134 
+    if group.admin_id == user_id:  # 管理员也不允许自己退出
135 
+        return response(GroupStatusCode.NO_QUIT_PERMISSION)
136 
+
137 
+    # 群组用户校验
138 
+    try:
139 
+        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
140 
+    except GroupUserInfo.DoesNotExist:
141 
+        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)
142 
+
143 
+    # 群组用户移除
144 
+    group_user.user_status = GroupUserInfo.QUIT
145 
+    group_user.quit_at = tc.utc_datetime()
146 
+    group_user.save()
147 
+
148 
+    # Redis 群组数据缓存更新
149 
+    group_users = set_group_users_info(group)
150 
+
151 
+    # Redis 群组删除集合缓存
152 
+    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
153 
+    r.sadd(GROUP_USERS_QUIT_SET % group_id, user_id)
154 
+
155 
+    return response(200, 'Quit Success', u'用户退出成功', {
156 
+        'group_id': group_id,
157 
+        'users': group_users,
158 
+    })
159 
+
160 
+
161 
+@logit
162 
+def group_pass_api(request):
163 
+    """ 申请通过 """
164 
+    group_id = request.POST.get('group_id', '')
165 
+    admin_id = request.POST.get('admin_id', '')
166 
+    user_id = request.POST.get('user_id', '')
167 
+
168 
+    # 群组校验
169 
+    try:
170 
+        group = GroupInfo.objects.get(group_id=group_id)
171 
+    except GroupInfo.DoesNotExist:
172 
+        return response(GroupStatusCode.GROUP_NOT_FOUND)
173 
+
174 
+    # 权限校验
175 
+    if group.admin_id != admin_id:
176 
+        return response(GroupStatusCode.NO_PASS_PERMISSION)
177 
+
178 
+    # 群组用户校验
179 
+    try:
180 
+        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
181 
+    except GroupUserInfo.DoesNotExist:
182 
+        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)
183 
+
184 
+    # 群组用户通过
185 
+    group_user.user_status = GroupUserInfo.PASSED
186 
+    group_user.passed_at = tc.utc_datetime()
187 
+    group_user.save()
188 
+
189 
+    # Redis 群组数据缓存更新
190 
+    group_users = set_group_users_info(group)
191 
+
192 
+    # Redis 群组通过集合缓存
193 
+    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
194 
+    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)
195 
+
196 
+    return response(200, 'Pass Success', u'申请通过成功', {
197 
+        'group_id': group_id,
198 
+        'users': group_users,
199 
+    })
200 
+
201 
+
202 
+@logit
203 
+def group_refuse_api(request):
204 
+    """ 申请拒绝 """
205 
+    group_id = request.POST.get('group_id', '')
206 
+    admin_id = request.POST.get('admin_id', '')
207 
+    user_id = request.POST.get('user_id', '')
208 
+
209 
+    # 群组校验
210 
+    try:
211 
+        group = GroupInfo.objects.get(group_id=group_id)
212 
+    except GroupInfo.DoesNotExist:
213 
+        return response(GroupStatusCode.GROUP_NOT_FOUND)
214 
+
215 
+    # 权限校验
216 
+    if group.admin_id != admin_id:
217 
+        return response(GroupStatusCode.NO_REFUSE_PERMISSION)
218 
+
219 
+    # 群组用户校验
220 
+    try:
221 
+        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
222 
+    except GroupUserInfo.DoesNotExist:
223 
+        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)
224 
+
225 
+    # 群组用户拒绝
226 
+    group_user.user_status = GroupUserInfo.REFUSED
227 
+    group_user.refused_at = tc.utc_datetime()
228 
+    group_user.save()
229 
+
230 
+    # Redis 群组数据缓存更新
231 
+    group_users = set_group_users_info(group)
232 
+
233 
+    # Redis 群组拒绝集合缓存
234 
+    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
235 
+    r.sadd(GROUP_USERS_REFUSED_SET % group_id, user_id)
236 
+
237 
+    return response(200, 'Refuse Success', u'申请拒绝成功', {
238 
+        'group_id': group_id,
239 
+        'users': group_users,
240 
+    })

+ 2 - 224
group/views.py
Bestand weergeven 

@@ -28,9 +28,8 @@ from utils.redis.rgroup import (del_group_photo_thumbup_flag, get_group_info, ge
28 28 
                                 get_group_photo_watchers, get_group_users_info, set_group_info,
29 29 
                                 set_group_photo_comment_list, set_group_photo_data, set_group_photo_thumbup_flag,
30 30 
                                 set_group_photo_thumbup_list, set_group_users_info)
31 
-from utils.redis.rkeys import (GROUP_LAST_PHOTO_PK, GROUP_PHOTO_WATCHER_SET, GROUP_USERS_APPLYING_SET,
32 
-                               GROUP_USERS_DELETED_SET, GROUP_USERS_PASSED_SET, GROUP_USERS_QUIT_SET,
33 
-                               GROUP_USERS_REFUSED_SET, LENSMAN_PHOTO_HAGGLE_TIMES, LENSMAN_PHOTO_PRICE)
31 
+from utils.redis.rkeys import (GROUP_LAST_PHOTO_PK, GROUP_PHOTO_WATCHER_SET, GROUP_USERS_PASSED_SET,
32 
+                               LENSMAN_PHOTO_HAGGLE_TIMES, LENSMAN_PHOTO_PRICE)
34 33 
 from utils.redis.rorder import get_lensman_order_record
35 34 
 from utils.redis.rprice import get_lensman_price_fixed
36 35 
 from utils.sql.raw import PAI2_HOME_API
 
@@ -177,64 +176,6 @@ def group_list_api(request):
177 176
178 177
179 178 
 @logit
180 
-def group_join_api(request):
181 
-    """ 申请加群 """
182 
-    group_id = request.POST.get('group_id', '')
183 
-    user_id = request.POST.get('user_id', '')
184 
-    nickname = request.POST.get('nickname', '')
185 
-
186 
-    # 用户校验
187 
-    try:
188 
-        user = UserInfo.objects.get(user_id=user_id)
189 
-    except UserInfo.DoesNotExist:
190 
-        return response(UserStatusCode.USER_NOT_FOUND)
191 
-
192 
-    # 群组校验
193 
-    try:
194 
-        group = GroupInfo.objects.get(group_id=group_id)
195 
-    except GroupInfo.DoesNotExist:
196 
-        return response(GroupStatusCode.GROUP_NOT_FOUND)
197 
-
198 
-    # 群组锁定校验
199 
-    if group.group_lock:
200 
-        return response(GroupStatusCode.GROUP_HAS_LOCKED)
201 
-
202 
-    # 群组用户记录创建，若记录不存在，则创建，若记录已存在，则更新
203 
-    group_user, created = GroupUserInfo.objects.get_or_create(
204 
-        group_id=group_id,
205 
-        user_id=user_id,
206 
-    )
207 
-    if group_user.user_status != GroupUserInfo.PASSED:
208 
-        group_user.current_id = -1 if group.group_from == GroupInfo.SESSION_GROUP else int(r.get(GROUP_LAST_PHOTO_PK % group_id) or -1)
209 
-        group_user.nickname = nickname or user.final_nickname
210 
-        group_user.avatar = user.avatar
211 
-        # group_user.admin = False  # Admin Field Default False, Should Not Assign
212 
-        group_user.user_status = GroupUserInfo.PASSED
213 
-        group_user.passed_at = tc.utc_datetime()
214 
-        group_user.save()
215 
-
216 
-    # Redis 群组用户数据缓存
217 
-    set_group_users_info(group)
218 
-
219 
-    # Redis 群组通过集合缓存
220 
-    r.srem(GROUP_USERS_REFUSED_SET % group_id, user_id)
221 
-    r.srem(GROUP_USERS_DELETED_SET % group_id, user_id)
222 
-    r.srem(GROUP_USERS_QUIT_SET % group_id, user_id)
223 
-    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)
224 
-
225 
-    curinfo = get_current_photos(group_id, user_id, group_user.current_id)
226 
-
227 
-    return response(200, 'Apply Success', u'申请成功', {
228 
-        'current_id': curinfo.get('current_id', ''),
229 
-        'photos': curinfo.get('photos', ''),
230 
-        'group_id': group_id,
231 
-        'group': get_group_info(group_id),
232 
-        'user_id': user_id,
233 
-        'users': get_group_users_info(group_id, user_id),
234 
-    })
235 
-
236 
-
237 
-@logit
238 179 
 def group_lock_api(request):
239 180 
     """ 群组锁定 """
240 181 
     group_id = request.POST.get('group_id', '')
 
@@ -287,169 +228,6 @@ def group_unlock_api(request):
287 228
288 229
289 230 
 @logit
290 
-def group_remove_api(request):
291 
-    """ 成员移除 """
292 
-    group_id = request.POST.get('group_id', '')
293 
-    admin_id = request.POST.get('admin_id', '')
294 
-    user_id = request.POST.get('user_id', '')
295 
-
296 
-    # 群组校验
297 
-    try:
298 
-        group = GroupInfo.objects.get(group_id=group_id)
299 
-    except GroupInfo.DoesNotExist:
300 
-        return response(GroupStatusCode.GROUP_NOT_FOUND)
301 
-
302 
-    # 权限校验
303 
-    if group.admin_id != admin_id or group.admin_id == user_id:  # 管理员也不允许将自己移除
304 
-        return response(GroupStatusCode.NO_REMOVE_PERMISSION)
305 
-
306 
-    # 群组用户校验
307 
-    try:
308 
-        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
309 
-    except GroupUserInfo.DoesNotExist:
310 
-        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)
311 
-
312 
-    # 群组用户移除
313 
-    group_user.user_status = GroupUserInfo.DELETED
314 
-    group_user.deleted_at = tc.utc_datetime()
315 
-    group_user.save()
316 
-
317 
-    # Redis 群组数据缓存更新
318 
-    group_users = set_group_users_info(group)
319 
-
320 
-    # Redis 群组删除集合缓存
321 
-    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
322 
-    r.sadd(GROUP_USERS_DELETED_SET % group_id, user_id)
323 
-
324 
-    return response(200, 'Remove Success', u'用户移除成功', {
325 
-        'group_id': group_id,
326 
-        'users': group_users,
327 
-    })
328 
-
329 
-
330 
-@logit
331 
-def group_quit_api(request):
332 
-    """ 成员退出 """
333 
-    group_id = request.POST.get('group_id', '')
334 
-    user_id = request.POST.get('user_id', '')
335 
-
336 
-    # 群组校验
337 
-    try:
338 
-        group = GroupInfo.objects.get(group_id=group_id)
339 
-    except GroupInfo.DoesNotExist:
340 
-        return response(GroupStatusCode.GROUP_NOT_FOUND)
341 
-
342 
-    # 权限校验
343 
-    if group.admin_id == user_id:  # 管理员也不允许自己退出
344 
-        return response(GroupStatusCode.NO_QUIT_PERMISSION)
345 
-
346 
-    # 群组用户校验
347 
-    try:
348 
-        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
349 
-    except GroupUserInfo.DoesNotExist:
350 
-        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)
351 
-
352 
-    # 群组用户移除
353 
-    group_user.user_status = GroupUserInfo.QUIT
354 
-    group_user.quit_at = tc.utc_datetime()
355 
-    group_user.save()
356 
-
357 
-    # Redis 群组数据缓存更新
358 
-    group_users = set_group_users_info(group)
359 
-
360 
-    # Redis 群组删除集合缓存
361 
-    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
362 
-    r.sadd(GROUP_USERS_QUIT_SET % group_id, user_id)
363 
-
364 
-    return response(200, 'Quit Success', u'用户退出成功', {
365 
-        'group_id': group_id,
366 
-        'users': group_users,
367 
-    })
368 
-
369 
-
370 
-@logit
371 
-def group_pass_api(request):
372 
-    """ 申请通过 """
373 
-    group_id = request.POST.get('group_id', '')
374 
-    admin_id = request.POST.get('admin_id', '')
375 
-    user_id = request.POST.get('user_id', '')
376 
-
377 
-    # 群组校验
378 
-    try:
379 
-        group = GroupInfo.objects.get(group_id=group_id)
380 
-    except GroupInfo.DoesNotExist:
381 
-        return response(GroupStatusCode.GROUP_NOT_FOUND)
382 
-
383 
-    # 权限校验
384 
-    if group.admin_id != admin_id:
385 
-        return response(GroupStatusCode.NO_PASS_PERMISSION)
386 
-
387 
-    # 群组用户校验
388 
-    try:
389 
-        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
390 
-    except GroupUserInfo.DoesNotExist:
391 
-        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)
392 
-
393 
-    # 群组用户通过
394 
-    group_user.user_status = GroupUserInfo.PASSED
395 
-    group_user.passed_at = tc.utc_datetime()
396 
-    group_user.save()
397 
-
398 
-    # Redis 群组数据缓存更新
399 
-    group_users = set_group_users_info(group)
400 
-
401 
-    # Redis 群组通过集合缓存
402 
-    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
403 
-    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)
404 
-
405 
-    return response(200, 'Pass Success', u'申请通过成功', {
406 
-        'group_id': group_id,
407 
-        'users': group_users,
408 
-    })
409 
-
410 
-
411 
-@logit
412 
-def group_refuse_api(request):
413 
-    """ 申请拒绝 """
414 
-    group_id = request.POST.get('group_id', '')
415 
-    admin_id = request.POST.get('admin_id', '')
416 
-    user_id = request.POST.get('user_id', '')
417 
-
418 
-    # 群组校验
419 
-    try:
420 
-        group = GroupInfo.objects.get(group_id=group_id)
421 
-    except GroupInfo.DoesNotExist:
422 
-        return response(GroupStatusCode.GROUP_NOT_FOUND)
423 
-
424 
-    # 权限校验
425 
-    if group.admin_id != admin_id:
426 
-        return response(GroupStatusCode.NO_REFUSE_PERMISSION)
427 
-
428 
-    # 群组用户校验
429 
-    try:
430 
-        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
431 
-    except GroupUserInfo.DoesNotExist:
432 
-        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)
433 
-
434 
-    # 群组用户拒绝
435 
-    group_user.user_status = GroupUserInfo.REFUSED
436 
-    group_user.refused_at = tc.utc_datetime()
437 
-    group_user.save()
438 
-
439 
-    # Redis 群组数据缓存更新
440 
-    group_users = set_group_users_info(group)
441 
-
442 
-    # Redis 群组拒绝集合缓存
443 
-    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
444 
-    r.sadd(GROUP_USERS_REFUSED_SET % group_id, user_id)
445 
-
446 
-    return response(200, 'Refuse Success', u'申请拒绝成功', {
447 
-        'group_id': group_id,
448 
-        'users': group_users,
449 
-    })
450 
-
451 
-
452 
-@logit
453 231 
 def group_data_api(request):
454 232 
     """ 群组数据, 评论数, 点赞数 """
455 233 
     group_id = request.POST.get('group_id', '')