@@ -16,7 +16,11 @@ urlpatterns = [  | 
            ||
| 16 | 16 | 
                 | 
            
| 17 | 17 | 
                urlpatterns = [  | 
            
| 18 | 18 | 
                url(r'^g/create$', group_views.group_create_api, name='group_create_api'), # 群组创建  | 
            
| 19 | 
                + url(r'^g/detail$', group_views.group_detail_api, name='group_detail_api'), # 群组详情  | 
            |
| 19 | 20 | 
                url(r'^g/join$', group_views.group_join_api, name='group_join_api'), # 申请加群  | 
            
| 21 | 
                + url(r'^g/lock$', group_views.group_lock_api, name='group_lock_api'), # 群组锁定  | 
            |
| 22 | 
                + url(r'^g/pass$', group_views.group_pass_api, name='group_pass_api'), # 申请通过  | 
            |
| 23 | 
                + url(r'^g/refuse$', group_views.group_refuse_api, name='group_refuse_api'), # 申请拒绝  | 
            |
| 20 | 24 | 
                ]  | 
            
| 21 | 25 | 
                 | 
            
| 22 | 26 | 
                urlpatterns += [  | 
            
                @@ -6,6 +6,7 @@  | 
            ||
| 6 | 6 | 
                4011 —— 用户名不存在  | 
            
| 7 | 7 | 
                4012 —— 用户密码错误  | 
            
| 8 | 8 | 
                 | 
            
| 9 | 
                +  | 
            |
| 9 | 10 | 
                2、照片上传 —— 401  | 
            
| 10 | 11 | 
                4010 —— 参数错误  | 
            
| 11 | 12 | 
                4011 —— 摄影师不存在  | 
            
                @@ -14,4 +15,10 @@  | 
            ||
| 14 | 15 | 
                 | 
            
| 15 | 16 | 
                3、群组信息 —— 402  | 
            
| 16 | 17 | 
                4020 —— 群组不存在  | 
            
| 17 | 
                - 4021 —— 群组已锁定  | 
            |
| 18 | 
                + 4021 —— 群组已锁定  | 
            |
| 19 | 
                + 4022 —— 非群组管理员  | 
            |
| 20 | 
                + 4023 —— 没有锁定权限  | 
            |
| 21 | 
                + 4024 —— 没有通过权限  | 
            |
| 22 | 
                + 4025 —— 没有拒绝权限  | 
            |
| 23 | 
                + 4026 —— 重复加群申请  | 
            |
| 24 | 
                + 4027 —— 加群申请不存在  | 
            
                @@ -6,7 +6,7 @@ from group.models import GroupInfo, GroupUserInfo, GroupPhotoInfo  | 
            ||
| 6 | 6 | 
                 | 
            
| 7 | 7 | 
                 | 
            
| 8 | 8 | 
                class GroupInfoAdmin(admin.ModelAdmin):  | 
            
| 9 | 
                -    list_display = ('group_id', 'group_name', 'group_desc', 'group_from', 'group_lock', 'status', 'created_at', 'updated_at')
               | 
            |
| 9 | 
                +    list_display = ('group_id', 'admin_id', 'group_name', 'group_desc', 'group_from', 'group_lock', 'status', 'created_at', 'updated_at')
               | 
            |
| 10 | 10 | 
                     list_filter = ('group_from', 'group_lock', 'status')
               | 
            
| 11 | 11 | 
                 | 
            
| 12 | 12 | 
                 | 
            
                @@ -0,0 +1,19 @@  | 
            ||
| 1 | 
                +# -*- coding: utf-8 -*-  | 
            |
| 2 | 
                +from __future__ import unicode_literals  | 
            |
| 3 | 
                +  | 
            |
| 4 | 
                +from django.db import models, migrations  | 
            |
| 5 | 
                +  | 
            |
| 6 | 
                +  | 
            |
| 7 | 
                +class Migration(migrations.Migration):  | 
            |
| 8 | 
                +  | 
            |
| 9 | 
                + dependencies = [  | 
            |
| 10 | 
                +        ('group', '0002_groupinfo_session_id'),
               | 
            |
| 11 | 
                + ]  | 
            |
| 12 | 
                +  | 
            |
| 13 | 
                + operations = [  | 
            |
| 14 | 
                + migrations.AddField(  | 
            |
| 15 | 
                + model_name='groupinfo',  | 
            |
| 16 | 
                + name='admin_id',  | 
            |
| 17 | 
                + field=models.CharField(help_text='\u7528\u6237\u552f\u4e00\u6807\u8bc6', max_length=255, null=True, verbose_name='admin_id', blank=True),  | 
            |
| 18 | 
                + ),  | 
            |
| 19 | 
                + ]  | 
            
                @@ -17,6 +17,7 @@ class GroupInfo(CreateUpdateMixin):  | 
            ||
| 17 | 17 | 
                )  | 
            
| 18 | 18 | 
                 | 
            
| 19 | 19 | 
                group_id = models.CharField(_(u'group_id'), max_length=255, blank=True, null=True, help_text=u'群组唯一标识', db_index=True, unique=True)  | 
            
| 20 | 
                + admin_id = models.CharField(_(u'admin_id'), max_length=255, blank=True, null=True, help_text=u'用户唯一标识')  | 
            |
| 20 | 21 | 
                group_name = models.CharField(_(u'group_name'), max_length=255, blank=True, null=True, help_text=u'群组名称')  | 
            
| 21 | 22 | 
                group_desc = models.TextField(_(u'group_desc'), blank=True, null=True, help_text=u'群组描述')  | 
            
| 22 | 23 | 
                group_from = models.IntegerField(_(u'group_from'), choices=GROUP_FROM, default=APP_GROUP, help_text=u'群组来源')  | 
            
                @@ -30,16 +31,28 @@ class GroupInfo(CreateUpdateMixin):  | 
            ||
| 30 | 31 | 
                def __unicode__(self):  | 
            
| 31 | 32 | 
                return unicode(self.group_id)  | 
            
| 32 | 33 | 
                 | 
            
| 33 | 
                - @property  | 
            |
| 34 | 
                - def users(self):  | 
            |
| 34 | 
                + def users(self, user_id):  | 
            |
| 35 | 35 | 
                all_users = GroupUserInfo.objects.filter(group_id=self.group_id)  | 
            
| 36 | 
                - applying_users = all_users.filter(user_status=GroupUserInfo.APPLYING)  | 
            |
| 36 | 
                +  | 
            |
| 37 | 37 | 
                passed_users = all_users.filter(user_status=GroupUserInfo.PASSED)  | 
            
| 38 | 
                + passed_count = passed_users.count()  | 
            |
| 39 | 
                + passed = [passed.user_info for passed in passed_users]  | 
            |
| 40 | 
                +  | 
            |
| 41 | 
                + if self.admin_id != user_id:  | 
            |
| 42 | 
                +            return {
               | 
            |
| 43 | 
                + 'passed_count': passed_count,  | 
            |
| 44 | 
                + 'passed': passed,  | 
            |
| 45 | 
                + }  | 
            |
| 46 | 
                +  | 
            |
| 47 | 
                + applying_users = all_users.filter(user_status=GroupUserInfo.APPLYING)  | 
            |
| 48 | 
                + applying_count = applying_users.count()  | 
            |
| 49 | 
                + applying = [applying.user_info for applying in applying_users]  | 
            |
| 50 | 
                +  | 
            |
| 38 | 51 | 
                         return {
               | 
            
| 39 | 
                - 'applying_count': applying_users.count(),  | 
            |
| 40 | 
                - 'passed_count': passed_users.count(),  | 
            |
| 41 | 
                - 'applying': [applying.user_info for applying in applying_users],  | 
            |
| 42 | 
                - 'passed': [passed.user_info for passed in passed_users],  | 
            |
| 52 | 
                + 'applying_count': applying_count,  | 
            |
| 53 | 
                + 'passed_count': passed_count,  | 
            |
| 54 | 
                + 'applying': applying,  | 
            |
| 55 | 
                + 'passed': passed,  | 
            |
| 43 | 56 | 
                }  | 
            
| 44 | 57 | 
                 | 
            
| 45 | 58 | 
                 | 
            
                @@ -86,8 +99,8 @@ class GroupPhotoInfo(CreateUpdateMixin):  | 
            ||
| 86 | 99 | 
                photo_thumbnail_path = models.CharField(_(u'photo_thumbnail_path'), max_length=255, blank=True, null=True, help_text=u'照片缩略图存放路径')  | 
            
| 87 | 100 | 
                 | 
            
| 88 | 101 | 
                class Meta:  | 
            
| 89 | 
                - verbose_name = _(u'groupuserinfo')  | 
            |
| 90 | 
                - verbose_name_plural = _(u'groupuserinfo')  | 
            |
| 102 | 
                + verbose_name = _(u'groupphotoinfo')  | 
            |
| 103 | 
                + verbose_name_plural = _(u'groupphotoinfo')  | 
            |
| 91 | 104 | 
                 | 
            
| 92 | 105 | 
                def __unicode__(self):  | 
            
| 93 | 106 | 
                return unicode(self.pk)  | 
            
                @@ -8,7 +8,7 @@ from group.models import GroupInfo, GroupUserInfo, GroupPhotoInfo  | 
            ||
| 8 | 8 | 
                class GroupInfoSerializer(serializers.HyperlinkedModelSerializer):  | 
            
| 9 | 9 | 
                class Meta:  | 
            
| 10 | 10 | 
                model = GroupInfo  | 
            
| 11 | 
                -        fields = ('group_id', 'group_name', 'group_desc', 'group_from', 'group_lock', 'status', 'created_at', 'updated_at')
               | 
            |
| 11 | 
                +        fields = ('group_id', 'admin_id', 'group_name', 'group_desc', 'group_from', 'group_lock', 'status', 'created_at', 'updated_at')
               | 
            |
| 12 | 12 | 
                 | 
            
| 13 | 13 | 
                 | 
            
| 14 | 14 | 
                class GroupUserInfoSerializer(serializers.HyperlinkedModelSerializer):  | 
            
                @@ -30,6 +30,7 @@ def group_create_api(request):  | 
            ||
| 30 | 30 | 
                group_id = CurtailUUID.uuid(GroupInfo, 'group_id')  | 
            
| 31 | 31 | 
                group = GroupInfo.objects.create(  | 
            
| 32 | 32 | 
                group_id=group_id,  | 
            
| 33 | 
                + admin_id=user_id,  | 
            |
| 33 | 34 | 
                group_from=GroupInfo.APP_GROUP,  | 
            
| 34 | 35 | 
                )  | 
            
| 35 | 36 | 
                GroupUserInfo.objects.create(  | 
            
                @@ -46,7 +47,37 @@ def group_create_api(request):  | 
            ||
| 46 | 47 | 
                'message': u'群组创建成功',  | 
            
| 47 | 48 | 
                         'data': {
               | 
            
| 48 | 49 | 
                'group_id': group_id,  | 
            
| 49 | 
                - 'users': group.users  | 
            |
| 50 | 
                + 'users': group.users(user_id)  | 
            |
| 51 | 
                + },  | 
            |
| 52 | 
                + })  | 
            |
| 53 | 
                +  | 
            |
| 54 | 
                +  | 
            |
| 55 | 
                +def group_detail_api(request):  | 
            |
| 56 | 
                +    group_id = request.POST.get('group_id', '')
               | 
            |
| 57 | 
                +    user_id = request.POST.get('user_id', '')
               | 
            |
| 58 | 
                +  | 
            |
| 59 | 
                + try:  | 
            |
| 60 | 
                + user = UserInfo.objects.get(user_id=user_id)  | 
            |
| 61 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 62 | 
                +        return JsonResponse({
               | 
            |
| 63 | 
                + 'status': 4011,  | 
            |
| 64 | 
                + 'message': u'用户不存在',  | 
            |
| 65 | 
                + })  | 
            |
| 66 | 
                +  | 
            |
| 67 | 
                + try:  | 
            |
| 68 | 
                + group = GroupInfo.objects.get(group_id=group_id)  | 
            |
| 69 | 
                + except GroupInfo.DoesNotExist:  | 
            |
| 70 | 
                +        return JsonResponse({
               | 
            |
| 71 | 
                + 'status': 4020,  | 
            |
| 72 | 
                + 'message': u'群组不存在',  | 
            |
| 73 | 
                + })  | 
            |
| 74 | 
                +  | 
            |
| 75 | 
                +    return JsonResponse({
               | 
            |
| 76 | 
                + 'status': 200,  | 
            |
| 77 | 
                + 'message': u'获取群组详情成功',  | 
            |
| 78 | 
                +        'data': {
               | 
            |
| 79 | 
                + 'group_id': group_id,  | 
            |
| 80 | 
                + 'users': group.users(user_id)  | 
            |
| 50 | 81 | 
                },  | 
            
| 51 | 82 | 
                })  | 
            
| 52 | 83 | 
                 | 
            
                @@ -77,6 +108,12 @@ def group_join_api(request):  | 
            ||
| 77 | 108 | 
                'message': u'群组已锁定',  | 
            
| 78 | 109 | 
                })  | 
            
| 79 | 110 | 
                 | 
            
| 111 | 
                + if GroupUserInfo.objects.filter(group_id=group_id, user_id=user_id, user_status__in=[GroupUserInfo.APPLYING, GroupUserInfo.PASSED]).exists():  | 
            |
| 112 | 
                +        return JsonResponse({
               | 
            |
| 113 | 
                + 'status': 4026,  | 
            |
| 114 | 
                + 'message': u'重复加群申请',  | 
            |
| 115 | 
                + })  | 
            |
| 116 | 
                +  | 
            |
| 80 | 117 | 
                GroupUserInfo.objects.create(  | 
            
| 81 | 118 | 
                group_id=group_id,  | 
            
| 82 | 119 | 
                user_id=user_id,  | 
            
                @@ -91,6 +128,148 @@ def group_join_api(request):  | 
            ||
| 91 | 128 | 
                })  | 
            
| 92 | 129 | 
                 | 
            
| 93 | 130 | 
                 | 
            
| 131 | 
                +def group_lock_api(request):  | 
            |
| 132 | 
                +    group_id = request.POST.get('group_id', '')
               | 
            |
| 133 | 
                +    user_id = request.POST.get('user_id', '')
               | 
            |
| 134 | 
                +  | 
            |
| 135 | 
                + try:  | 
            |
| 136 | 
                + user = UserInfo.objects.get(user_id=user_id)  | 
            |
| 137 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 138 | 
                +        return JsonResponse({
               | 
            |
| 139 | 
                + 'status': 4011,  | 
            |
| 140 | 
                + 'message': u'用户不存在',  | 
            |
| 141 | 
                + })  | 
            |
| 142 | 
                +  | 
            |
| 143 | 
                + try:  | 
            |
| 144 | 
                + group = GroupInfo.objects.get(group_id=group_id)  | 
            |
| 145 | 
                + except GroupInfo.DoesNotExist:  | 
            |
| 146 | 
                +        return JsonResponse({
               | 
            |
| 147 | 
                + 'status': 4020,  | 
            |
| 148 | 
                + 'message': u'群组不存在',  | 
            |
| 149 | 
                + })  | 
            |
| 150 | 
                + if group.admin_id != user_id:  | 
            |
| 151 | 
                +        return JsonResponse({
               | 
            |
| 152 | 
                + 'status': 4023,  | 
            |
| 153 | 
                + 'message': u'没有锁定权限',  | 
            |
| 154 | 
                + })  | 
            |
| 155 | 
                +  | 
            |
| 156 | 
                + group.group_lock = True  | 
            |
| 157 | 
                + group.save()  | 
            |
| 158 | 
                +  | 
            |
| 159 | 
                +    return JsonResponse({
               | 
            |
| 160 | 
                + 'status': 200,  | 
            |
| 161 | 
                + 'message': u'锁定成功',  | 
            |
| 162 | 
                + })  | 
            |
| 163 | 
                +  | 
            |
| 164 | 
                +  | 
            |
| 165 | 
                +def group_pass_api(request):  | 
            |
| 166 | 
                +    group_id = request.POST.get('group_id', '')
               | 
            |
| 167 | 
                +    admin_id = request.POST.get('admin_id', '')
               | 
            |
| 168 | 
                +    user_id = request.POST.get('user_id', '')
               | 
            |
| 169 | 
                +  | 
            |
| 170 | 
                + try:  | 
            |
| 171 | 
                + admin = UserInfo.objects.get(user_id=admin_id)  | 
            |
| 172 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 173 | 
                +        return JsonResponse({
               | 
            |
| 174 | 
                + 'status': 4011,  | 
            |
| 175 | 
                + 'message': u'用户不存在',  | 
            |
| 176 | 
                + })  | 
            |
| 177 | 
                + try:  | 
            |
| 178 | 
                + user = UserInfo.objects.get(user_id=user_id)  | 
            |
| 179 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 180 | 
                +        return JsonResponse({
               | 
            |
| 181 | 
                + 'status': 4011,  | 
            |
| 182 | 
                + 'message': u'用户不存在',  | 
            |
| 183 | 
                + })  | 
            |
| 184 | 
                +  | 
            |
| 185 | 
                + try:  | 
            |
| 186 | 
                + group = GroupInfo.objects.get(group_id=group_id)  | 
            |
| 187 | 
                + except GroupInfo.DoesNotExist:  | 
            |
| 188 | 
                +        return JsonResponse({
               | 
            |
| 189 | 
                + 'status': 4020,  | 
            |
| 190 | 
                + 'message': u'群组不存在',  | 
            |
| 191 | 
                + })  | 
            |
| 192 | 
                + if group.admin_id != admin_id:  | 
            |
| 193 | 
                +        return JsonResponse({
               | 
            |
| 194 | 
                + 'status': 4024,  | 
            |
| 195 | 
                + 'message': u'没有通过权限',  | 
            |
| 196 | 
                + })  | 
            |
| 197 | 
                +  | 
            |
| 198 | 
                + try:  | 
            |
| 199 | 
                + group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)  | 
            |
| 200 | 
                + except GroupUserInfo.DoesNotExist:  | 
            |
| 201 | 
                +        return JsonResponse({
               | 
            |
| 202 | 
                + 'status': 4027,  | 
            |
| 203 | 
                + 'message': u'加群申请不存在',  | 
            |
| 204 | 
                + })  | 
            |
| 205 | 
                + group_user.user_status = GroupUserInfo.PASSED  | 
            |
| 206 | 
                + group_user.passed_at = tc.utc_datetime()  | 
            |
| 207 | 
                + group_user.save()  | 
            |
| 208 | 
                +  | 
            |
| 209 | 
                +    return JsonResponse({
               | 
            |
| 210 | 
                + 'status': 200,  | 
            |
| 211 | 
                + 'message': u'申请通过成功',  | 
            |
| 212 | 
                +        'data': {
               | 
            |
| 213 | 
                + 'group_id': group_id,  | 
            |
| 214 | 
                + 'users': group.users(user_id)  | 
            |
| 215 | 
                + },  | 
            |
| 216 | 
                + })  | 
            |
| 217 | 
                +  | 
            |
| 218 | 
                +  | 
            |
| 219 | 
                +def group_refuse_api(request):  | 
            |
| 220 | 
                +    group_id = request.POST.get('group_id', '')
               | 
            |
| 221 | 
                +    admin_id = request.POST.get('admin_id', '')
               | 
            |
| 222 | 
                +    user_id = request.POST.get('user_id', '')
               | 
            |
| 223 | 
                +  | 
            |
| 224 | 
                + try:  | 
            |
| 225 | 
                + admin = UserInfo.objects.get(user_id=admin_id)  | 
            |
| 226 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 227 | 
                +        return JsonResponse({
               | 
            |
| 228 | 
                + 'status': 4011,  | 
            |
| 229 | 
                + 'message': u'用户不存在',  | 
            |
| 230 | 
                + })  | 
            |
| 231 | 
                + try:  | 
            |
| 232 | 
                + user = UserInfo.objects.get(user_id=user_id)  | 
            |
| 233 | 
                + except UserInfo.DoesNotExist:  | 
            |
| 234 | 
                +        return JsonResponse({
               | 
            |
| 235 | 
                + 'status': 4011,  | 
            |
| 236 | 
                + 'message': u'用户不存在',  | 
            |
| 237 | 
                + })  | 
            |
| 238 | 
                +  | 
            |
| 239 | 
                + try:  | 
            |
| 240 | 
                + group = GroupInfo.objects.get(group_id=group_id)  | 
            |
| 241 | 
                + except GroupInfo.DoesNotExist:  | 
            |
| 242 | 
                +        return JsonResponse({
               | 
            |
| 243 | 
                + 'status': 4020,  | 
            |
| 244 | 
                + 'message': u'群组不存在',  | 
            |
| 245 | 
                + })  | 
            |
| 246 | 
                + if group.admin_id != admin_id:  | 
            |
| 247 | 
                +        return JsonResponse({
               | 
            |
| 248 | 
                + 'status': 4025,  | 
            |
| 249 | 
                + 'message': u'没有拒绝权限',  | 
            |
| 250 | 
                + })  | 
            |
| 251 | 
                +  | 
            |
| 252 | 
                + try:  | 
            |
| 253 | 
                + group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)  | 
            |
| 254 | 
                + except GroupUserInfo.DoesNotExist:  | 
            |
| 255 | 
                +        return JsonResponse({
               | 
            |
| 256 | 
                + 'status': 4027,  | 
            |
| 257 | 
                + 'message': u'加群申请不存在',  | 
            |
| 258 | 
                + })  | 
            |
| 259 | 
                + group_user.user_status = GroupUserInfo.REFUSED  | 
            |
| 260 | 
                + group_user.refused_at = tc.utc_datetime()  | 
            |
| 261 | 
                + group_user.save()  | 
            |
| 262 | 
                +  | 
            |
| 263 | 
                +    return JsonResponse({
               | 
            |
| 264 | 
                + 'status': 200,  | 
            |
| 265 | 
                + 'message': u'申请拒绝成功',  | 
            |
| 266 | 
                +        'data': {
               | 
            |
| 267 | 
                + 'group_id': group_id,  | 
            |
| 268 | 
                + 'users': group.users(user_id)  | 
            |
| 269 | 
                + },  | 
            |
| 270 | 
                + })  | 
            |
| 271 | 
                +  | 
            |
| 272 | 
                +  | 
            |
| 94 | 273 | 
                class GroupInfoViewSet(viewsets.ModelViewSet):  | 
            
| 95 | 274 | 
                     queryset = GroupInfo.objects.all().order_by('-created_at')
               | 
            
| 96 | 275 | 
                serializer_class = GroupInfoSerializer  |