def put(self, request, groupname): group = self.get_group(groupname) update = {"users": request.data} # spec wants list as request body serializer = GroupSerializer(group, update, partial=True) if serializer.is_valid(): serializer.save() return Response(status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, groupname): group = self.get_group(groupname) update = {"users": request.data} # spec wants list as request body serializer = GroupSerializer(group, update, partial=True) if serializer.is_valid(): serializer.save() return Response(status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProfileRetrieveUpdateSerializer(serializers.ModelSerializer): countries_available = SimpleCountrySerializer(many=True, read_only=True) supervisor = serializers.CharField(read_only=True) groups = GroupSerializer(source="user.groups", read_only=True, many=True) supervisees = serializers.PrimaryKeyRelatedField(source='user.supervisee', many=True, read_only=True) name = serializers.CharField(source='user.get_full_name', read_only=True) t2f = T2FUserDataSerializer(source='user') last_login = serializers.CharField(source='user.last_login', read_only=True) is_superuser = serializers.CharField(source='user.is_superuser', read_only=True) username = serializers.CharField(source='user.username', read_only=True) first_name = serializers.CharField(source='user.first_name', read_only=True) last_name = serializers.CharField(source='user.last_name', read_only=True) email = serializers.CharField(source='user.email', read_only=True) is_staff = serializers.CharField(source='user.is_staff', read_only=True) is_active = serializers.CharField(source='user.is_active', read_only=True) country = CountrySerializer(read_only=True) show_ap = serializers.SerializerMethodField() class Meta: model = UserProfile exclude = ('id', ) # TODO remove once feature gating is in place. def get_show_ap(self, obj): """If user is within one of the allowed countries then show_ap is True, otherwise False """ if obj.country.name in AP_ALLOWED_COUNTRIES: return True return False
def test_group_query(self, process_mock): all_groups = [{ "name": "certusers", "gid": "29", "members": ["root", "_jabber", "_postfix", "_cyrus", "_calendar", "_dovecot"], }, { "name": "_postdrop", "gid": "28", "members": [] }] process_mock.return_value = all_groups url = '{}?name=certusers&gid=29'.format(reverse('groups-query')) response = self.client.get(url) group = get_groups(settings.GRP_FILEPATH)['29'] serializer = GroupSerializer(instance=[group], many=True) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, serializer.data) url = '{}?name=blah'.format(reverse('groups-query')) response = self.client.get(url) # user with name blah doesn't exist, so 404 self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) self.assertEqual(response.data['detail'], "Group not found")
def retrieve(self, request, pk=None): try: group = self.all_groups[pk] except KeyError: raise NotFound(detail="Group not found", code=404) serializer = GroupSerializer(instance=group) return Response(serializer.data)
def create(cls, root, info, **kwargs): """ @description: 创建教师 @param {type} @return: """ data = kwargs.get("input") profile_data = data.pop("profile", None) if profile_data is None: return cls.get_errors("没有传入profile!") if profile_data.get("name", None) is None: return cls.get_errors("没有传入name!") tg = get_Object_or_None(Group, name="教师") if not tg: return cls.get_errors("没有教师组!") # 创建用户 user_ser = UserSerializer(data=data) ok, user = cls.save(user_ser, root, info) if not ok: return cls.get_errors(user) profile_data["user"] = user.id profile_data["creator"] = info.context.user.id # 创建对应profile profile_ser = UserProfileSerializer(data=profile_data) ok, profile = cls.save(profile_ser, root, info) if not ok: user.delete() return cls.get_errors(profile) # 创建对应组 group_ser = GroupSerializer(data={"name": profile_data.get("name")}) ok, group = cls.save(group_ser, root, info) if not ok: profile.delete() user.delete() return cls.get_errors(group) # 创建对应组profile gp_ser = GroupProfileSerializer( data={ "creator": info.context.user.id, "group": group.id, "parent_group": tg.id, }) ok, gp = cls.save(gp_ser, root, info) if not ok: profile.delete() user.delete() group.delete() return cls.get_errors(gp) user.groups.add(group) user.groups.add(tg) return cls.perform_mutate(user, info)
class EventSerializer(serializers.ModelSerializer): group = GroupSerializer(many=True) starting_time = serializers.DateTimeField(source='timeslot.starting_time') ending_time = serializers.DateTimeField(source='timeslot.ending_time') class_info = ClassEventSerializer(source='current_class') room = RoomSerializer() class Meta: model = Event fields = ("id", "class_info", "room", "group", "starting_time", "ending_time", "date")
def update(cls, root, info, **kwargs): data = kwargs.pop("input") profile_data = data.pop("profile", {}) profile_data["updater"] = info.context.user.id pk = data.pop("id") group = get_Object_or_None(Group, pk=pk) if not group: return cls.get_errors([ ErrorType( field="id", messages=[ "A {} obj with id: {} do not exist".format( "Group", pk) ], ) ]) group_ser = GroupSerializer(instance=group, data=data, partial=True) if not group_ser.is_valid(): errors = [ ErrorType(field=key, messages=value) for key, value in group_ser.errors.items() ] return cls.get_errors(errors) profile = GroupProfile.objects.filter(group_id=group.id) profile_ser = GroupProfileSerializer(instance=profile, data=profile_data, partial=True) ok, profile = cls.save(profile_ser, root, info) if not ok: return cls.get_errors(profile) group = group_ser.save() profile_ser.save() return cls.perform_mutate(group, info)
def create(cls, root, info, **kwargs): data = kwargs.get("input") profile_data = data.pop("profile", {}) profile_data["creator"] = info.context.user.id group_ser = GroupSerializer(data=data) ok, group = cls.save(group_ser, root, info) if not ok: return cls.get_errors(group) profile_data["group"] = group.id profile_ser = GroupProfileSerializer(data=profile_data) ok, profile = cls.save(profile_ser, root, info) if not ok: group.delete() return cls.get_errors(profile) return cls.perform_mutate(group, info)
def validate(self, attrs): code = attrs.get('code') result = self._credentials_validation(code) user = self._get_or_create_user(result['openid'], result['session_key']) r = urlopen(attrs.get('avatarUrl')) user.avatar.save("{}_{}.jpg".format(user.id, int(time.time())), File(BytesIO(r.read()))) attrs['username'] = result['openid'] attrs['password'] = result['openid'] self._update_userinfo(user, attrs) credentials = { self.username_field: attrs.get(self.username_field), 'password': attrs.get('password') } if all(credentials.values()): user = authenticate(**credentials) if user: if not user.is_active: msg = _('账户未激活') raise serializers.ValidationError(msg) payload = jwt_payload_handler(user) data_dict = { 'token': jwt_encode_handler(payload), 'name': user.name if user.name else user.username, 'groups': GroupSerializer(user.groups.all(), many=True).data, 'permissions': User.get_all_permissions(user) } data_dict.update( UserDetailSerializer(user, context=self.context).data) attrs.update(data_dict) return attrs else: msg = _('账号或密码不正确') raise serializers.ValidationError(msg) else: msg = _('必须包含用户信息或者code') raise serializers.ValidationError(msg)
def query(self, request): groupname = request.query_params.get('name', None) gid = request.query_params.get('gid', None) members = request.query_params.getlist('member', None) filterset = self.all_groups.values() if groupname is not None: filterset = [obj for obj in filterset if obj.name == groupname] if gid is not None: filterset = [obj for obj in filterset if obj.gid == gid] if members is not None: filterset = [obj for obj in filterset if all(member_name in obj.members for member_name in members)] if not filterset: raise NotFound(detail="Group not found", code=404) serializer = GroupSerializer(instance=filterset, many=True) return Response(serializer.data)
def test_group_retrieve(self, process_mock): all_groups = [{ "name": "certusers", "gid": "29", "members": ["root", "_jabber", "_postfix", "_cyrus", "_calendar", "_dovecot"], }, { "name": "_postdrop", "gid": "28", "members": [] }] process_mock.return_value = all_groups pk = '28' url = reverse('groups-detail', kwargs={'pk': pk}) response = self.client.get(url) group = get_groups(settings.GRP_FILEPATH)[pk] serializer = GroupSerializer(instance=group) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, serializer.data)
def test_group_list(self, process_mock): all_groups = [{ "name": "certusers", "gid": "29", "members": ["root", "_jabber", "_postfix", "_cyrus", "_calendar", "_dovecot"], }, { "name": "_postdrop", "gid": "28", "members": [] }] process_mock.return_value = all_groups url = reverse('groups-list') response = self.client.get(url) serializer = GroupSerializer(instance=get_groups( settings.GRP_FILEPATH).values(), many=True) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, serializer.data)
def test_user_groups(self, process_pwd_mock, process_grp_mock): all_users = [{ 'name': '_appowner', 'uid': '87', 'gid': '87', 'comment': 'Application Owner', 'home': '/var/empty', 'shell': '/usr/bin/false' }, { 'name': '_ard', 'uid': '67', 'gid': '67', 'comment': 'Apple Remote Desktop', 'home': '/var/empty', 'shell': '/usr/bin/false' }] all_groups = [ { "name": "certusers", "gid": "29", "members": [ "root", "_jabber", "_postfix", "_cyrus", "_calendar", "_appowner" ], }, ] process_pwd_mock.return_value = all_users process_grp_mock.return_value = all_groups pk = '87' url = reverse('users-groups', kwargs={'pk': pk}) response = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) groups = get_groups(settings.GRP_FILEPATH).values() serializer = GroupSerializer(instance=groups, many=True) self.assertEqual(response.data, serializer.data)
def groups(self, request, pk=None): try: user = self.all_users[pk] except KeyError: raise NotFound(detail="User not found in any groups", code=404) try: groups = get_groups(settings.GRP_FILEPATH).values() except IOError: raise NotFound('Invalid File: {}'.format(settings.GRP_FILEPATH)) try: groups = get_groups(settings.GRP_FILEPATH).values() except IOError: raise NotFound('Invalid File: {}'.format(settings.GRP_FILEPATH)) filtered_groups = [] for group in groups: if user.name in group.members: filtered_groups.append(group) serializer = GroupSerializer(instance=filtered_groups, many=True) return Response(serializer.data)
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) if serializer.is_valid(): user = serializer.object.get('user') or request.user token = serializer.object.get('token') response_data = jwt_response_payload_handler(token, user, request) response_data.update(UserDetailSerializer(user).data) response_data["groups"] = GroupSerializer(user.groups.all(), many=True).data response_data["permissions"] = sorted( User.get_all_permissions(user)) response = Response(response_data) if api_settings.JWT_AUTH_COOKIE: expiration = (datetime.utcnow() + api_settings.JWT_EXPIRATION_DELTA) response.set_cookie(api_settings.JWT_AUTH_COOKIE, token, expires=expiration, httponly=True) return response return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, user_id, *args, **kwargs): user = get_object_or_404(User, pk=user_id) serializer = GroupSerializer(user.group) return Response(serializer.data, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs): instance = self.get_object() data = GroupSerializer(instance).data instance.delete() return Response(data, status=status.HTTP_204_NO_CONTENT)
def get(self, request, groupname): group = self.get_group(groupname) serializer = GroupSerializer(group) return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request): serializer = GroupSerializer(instance=self.all_groups.values(), many=True) return Response(serializer.data)
def update(cls, root, info, **kwargs): data = kwargs.get("input") profile_data = data.pop("profile", None) data = kwargs.get("input") profile_data = data.pop("profile", {}) # 只有教师才可以修改其他用户的信息 # 否则就算是传入了id也只能修改自己的信息 pk = data.pop("id") user = info.context.user if user.is_staff: user = get_Object_or_None(User, pk=pk) if not user: return cls.get_errors(__fill_error("id", "用户不存在!")) if user.is_staff: user = info.context.user profile_data["updater"] = user.id # 如果更改了name属性,则先检查组内是否有同名组 name = profile_data.get("name", None) if name: if get_Object_or_None(group, name=name): return cls.get_errors(__fill_error("name", "已经存在同名组:" + name)) user_ser = UserSerializer(instance=user, data=data, partial=True) if not user_ser.is_valid(): errors = [ ErrorType(field=key, messages=value) for key, value in user_ser.errors.items() ] return cls.get_errors(errors) group = user.groups.all().filter(name=user.profile.name).first() group_ser = GroupSerializer(instance=group, data={"name": name}, partial=True) if not group_ser.is_valid(): errors = [ ErrorType(field=key, messages=value) for key, value in group_ser.errors.items() ] return cls.get_errors(errors) gp_ser = GroupProfileSerializer(instance=group.profile, data={}, partial=True) if not gp_ser.is_valid(): errors = [ ErrorType(field=key, messages=value) for key, value in gp_ser.errors.items() ] return cls.get_errors(errors) profile = UserProfile.objects.filter(user_id=user.id).first() profile_ser = None if not profile: profile_ser = UserProfileSerializer(data=profile_data) else: profile_ser = UserProfileSerializer(instance=profile, data=profile_data, partial=True) ok, profile = cls.save(profile_ser, root, info) if not ok: return cls.get_errors(profile) user_ser.save() group_ser.save() gp_ser.save() return cls.perform_mutate(user, info)
def get(self, request): groups = Group.objects.all() groups_serialized = GroupSerializer(groups, many=True) return Response(groups_serialized.data)