class InspectionAttachmentSerializer(FileSerializerMixin, FieldPermissionsSerializerMixin, serializers.ModelSerializer): id = serializers.IntegerField(required=False) uploader = UserSerializer() file = serializers.SerializerMethodField('get_file_url') filename = serializers.SerializerMethodField('get_file_filename') class Meta: model = InspectionAttachment fields = ('id', 'file', 'filename', 'uploader', 'uploaded_at', 'inspection') download_url_name = 'inspectionattachment-download' def override_permission_check_field_name(self, field_name): if field_name == 'filename': return 'file' return field_name
class CollectionLetterSerializer(FileSerializerMixin, FieldPermissionsSerializerMixin, serializers.ModelSerializer): id = serializers.IntegerField(required=False) uploader = UserSerializer() file = serializers.SerializerMethodField('get_file_url') filename = serializers.SerializerMethodField('get_file_filename') class Meta: model = CollectionLetter fields = ('id', 'lease', 'file', 'filename', 'uploader', 'uploaded_at') download_url_name = 'collectionletter-download' def override_permission_check_field_name(self, field_name): if field_name == 'filename': return 'file' return field_name
def _get_users(project, list_view=False): users = [project.user] if not list_view: attributes = Attribute.objects.filter( value_type=Attribute.TYPE_USER).values_list("identifier", flat=True) user_attribute_ids = [] for attribute in attributes: user_id = project.attribute_data.get(attribute, None) if user_id: user_attribute_ids.append(user_id) users += list(User.objects.filter(uuid__in=user_attribute_ids)) return UserSerializer(users, many=True).data
def update(self, request, pk): """ Updates a User with the given data :param request: HttpRequest :param pk: User primary key :return: Response """ user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): user = serializer.save() return Response(serializer.data, status=status.HTTP_202_ACCEPTED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class MessageWebSocketSerializer(serializers.ModelSerializer): permissions = serializers.SerializerMethodField() author = UserSerializer(many=False, read_only=True) class Meta: model = Message fields = ["content", "author", "created_on", "permissions"] read_only_fields = ["created_on", "id"] def get_permissions(self, obj): return { "write": obj.has_object_write_permission_socket(self.context["user"]), "read": obj.has_object_read_permission_socket(self.context["user"]), }
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) try: serializer.is_valid(raise_exception=True) except TokenError as e: raise InvalidToken(e.args[0]) user = User.objects.get(email=request.data['email']) req = request req.user = user user_serializer = UserSerializer(instance=user, context={'request': req}) res = {'user': user_serializer.data, **serializer.validated_data} return Response(res, status=status.HTTP_200_OK)
def post(self, request, format=None): username = request.data.get('username', '') password = request.data.get('password', '') user = auth.authenticate(username=username, password=password) if user is not None: if user.is_active: auth.login(request, user) return http.JsonResponse( UserSerializer(user, context={ 'request': request }).data) else: return http.HttpResponseBadRequest("User is deactivate") else: return http.HttpResponseBadRequest("Username or password is wrong")
class ChatSerializer(serializers.ModelSerializer): user = UserSerializer() subject = SubjectSerializer() favorite = serializers.SerializerMethodField() def get_favorite(self, message): user = self.context.get("request_user", None) if not user is None: return ChatFavorites.objects.filter(Q(user = user) & Q(message = message)).exists() return False class Meta: model = TalkMessages fields = ('text', 'user', 'subject', 'image_url', 'create_date', 'favorite', 'id')
def user_register(request): if request.user.is_authenticated or request.method != 'POST': return HttpResponse(status=400) data = json.loads(request.body) user = authenticate(**data) if not user: user = User.objects.create_user(**data) user.save() login(request, user) context = UserSerializer(user).data return JsonResponse(context, status=201) return HttpResponse(status=400)
def login(cls, email, password): try: user = User.objects.get(email=email) except User.DoesNotExist: return Response(data={'message': '404001 用户未注册'}, status=status.HTTP_404_NOT_FOUND) if user.check_password(password): token = get_jwt_token(user) return Response({ 'jwt': token, 'user': UserSerializer(user).data }, status=status.HTTP_200_OK) else: return Response(data={'message': '401001 密码错误'}, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None): token = request.data.get('userToken') site_id = request.data.get('siteId') user_id = request.data.get('userId') site = Site.objects.get(id=site_id) user = User.objects.get(id=user_id) site.users.remove(user) users = User.objects.all() user_serializer = UserSerializer(users, many=True) user = Token.objects.get(key=token).user sites = user.sites.all() site_serializer = SiteUserSerializer(sites, many=True) return Response({ 'users': user_serializer.data, 'sites': site_serializer.data })
class CompanyKeyFiguresLogoSerializer(serializers.ModelSerializer): """ CompanySerializer, which also serializes key figures of the company and his logo. """ user = UserSerializer() key_figures = KeyFiguresSerializer(source="keyfigures") logo = serializers.ImageField(source="user.profile.company_logo", allow_null=True, default=None) class Meta: model = Company fields = ("isin", "name", "country", "cash", "shares", "user", "key_figures", "id", "logo") read_only_fields = fields
def put(self, request, *args, **kwargs): """ 更新用户信息 """ form = UpdateUserInfoForm(request.data, request.FILES) if not form.is_valid(): return Response({'Detail': form.errors}, status=status.HTTP_400_BAD_REQUEST) cld = form.cleaned_data serializer = UserSerializer(request.user) try: serializer.update_userinfo(request, request.user, cld) except Exception as e: return Response({'Detail': e.args}, status=status.HTTP_400_BAD_REQUEST) return Response(serializer.data, status=status.HTTP_206_PARTIAL_CONTENT)
def create_user(request): if request.method == "POST": user_serializer = UserSerializer(data=request.data) if user_serializer.is_valid(): User.objects.create_user( username=user_serializer.validated_data["username"], password=user_serializer.validated_data["password"]) return Response(JSONResponse().addData( "User", user_serializer.data).addData("status", "User created!").send(), status=status.HTTP_201_CREATED) else: return Response(JSONResponse().addError( 0, "User could not be created").addError( 1, user_serializer.errors).send(), status=status.HTTP_400_BAD_REQUEST)
def friends_list(self, request): groups = Group.objects.filter( Q(owner=request.user) | Q(members=request.user)).distinct() serializer = FriendsListSerializer(groups, many=True) friends = [] for group in serializer.data: friends = [ *friends, *list( filter(lambda member: member.id != request.user.id, group.get('members'))) ] serializer = UserSerializer(set(friends), many=True) paginator = PageNumberPagination() paginator.page_size = 50 data = paginator.paginate_queryset(serializer.data, request) return paginator.get_paginated_response(data=data)
def put(self, request, pk): """ Updates a user :param request: HttpRequest object :param pk: user pk :return: HttpResponse object """ user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_202_ACCEPTED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class InventorySupplyHeaderSerializer(serializers.ModelSerializer): """ This header serializer is used in case of listing contents of particular InventoryReport (not InventorySupply) Instead of serializing all details of a supply (supplies.models.Supply), only ID and name is serialized The rest of details can be accessed by '/api/inventories/supplies/<int:pk>' with ID provided by this serializer This will future-proof that adding more details to supply (e.g. image) won't attach unnecessary data to InventoryReport details view """ supply = SupplyHeaderSerializer(source='inventory_supply', many=False, read_only=True) checked_by = UserSerializer() class Meta: model = InventorySupply fields = ('supply', 'is_checked', 'checked_by')
def post(self, request, *args, **kwargs): data = request.data token = data.get('token', ) user = get_object_or_404(User, token=token) if user is not None: if user.is_active: login(request, user) serializer = UserSerializer(user) return Response(data=serializer.data, status=status.HTTP_200_OK) else: return Response(status=status.HTTP_404_NOT_FOUND) else: return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None): response = Response() #hashs password for proper safety request.data["password"] = make_password(request.data["password"]) new_user = UserSerializer(data=request.data) if new_user.is_valid(): user = new_user.save() response.status_code = 201 token = Token.objects.create(user=user) response['token'] = token.key else: response.status_code = 400 response['error'] = new_user.errors return response
def setUp(self): self.user_attributes = { "email": "*****@*****.**", "password": "******", "first_name": "Test", "last_name": "Me", "major": "Testing Studies", "minor": "Unit Testing", "year": 2, "self_bio": "I'm a unit test that should pass", } self.serializer = UserSerializer(data=self.user_attributes) if self.serializer.is_valid(): user = self.serializer.save() self.user = User.objects.get(email=self.user_attributes['email'])
def update(self, request, pk): # Debemos comprobar el sl usuario que se desea actualizar existe user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) # Serializame este usuario(instance=user) con estos datos(data=request.data) serializer = UserSerializer(instance=user, data=request.data) # Validamos if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, pk): """PATCH method for editing user's name and password""" instance = User.objects.get(pk=pk) serializer = UserUpdateSerializer(instance, data=request.data, partial=True) if not serializer.is_valid(): return Response(data=serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: new_user = serializer.save() except: return Response(data={'error': sys.exc_info()[0]}, status=status.HTTP_400_BAD_REQUEST) serializer = UserSerializer(new_user) return Response(data=serializer.data, status=status.HTTP_202_ACCEPTED)
def test_login_token(self): user = DummyUser().create() user.is_active = True user.save() response = self.client.post(reverse('user:login'), { 'email': DummyUser().EMAIL, 'password': DummyUser().PASSWORD, }) expected_data = { 'token': user.token, 'user': UserSerializer(user).data, } expected_data_json = JSONRenderer().render(expected_data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.content, expected_data_json)
def update(self, request, pk): """ Actualiza el usuario con pk <pk> si existe. :param request: objeto de tipo HttpRequest :param pk: pk del usuario que queremos actualizar :return: 202 si OK o 400 con errores """ user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_202_ACCEPTED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class TreeCommentSerializer(serializers.ModelSerializer): descendants = CommentSerializer(many=True, read_only=True) user = UserSerializer(read_only=True) comment_html = serializers.CharField() class Meta: model = BlogComment fields = [ "id", "comment_html", "submit_date", "user", "parent", "descendants", ] extra_kwargs = {"submit_date": {"format": "%Y-%m-%d %H:%M:%S"}}
class ConsultaEventoSerializer(serializers.ModelSerializer): ubicacion = UbicacionSerializer() rubro = RubroEventoSerializer(read_only=True) rubro_id = serializers.PrimaryKeyRelatedField( queryset=RubroEvento.objects.all(), source='rubro', write_only=True) contacto = ContactoSerializer(many=True) necesidades = NecesidadSerializer(many=True) voluntarios = VoluntarioSerializer(many=True) organizacion = UserSerializer() class Meta: model = Evento fields = ('id', 'nombre', 'descripcion', 'fecha_hora_inicio', 'fecha_hora_fin', 'rubro', 'rubro_id', 'ubicacion', 'contacto', 'organizacion_id', 'necesidades', 'organizacion', 'voluntarios')
class CommunitySerializer(serializers.ModelSerializer): users = UserSerializer(many=True, required=False) class Meta: model = Community fields = ['name', 'users'] extra_kwargs = {'name': {'validators': []}} def create(self, validated_data): usersData = validated_data.pop('users') community = Community.objects.create(**validated_data) for user in usersData: user, created = User.objects.get_or_create( username=user['username'], email=user['email'], first_name=user['first_name'], last_name=user['last_name'], password=user['password']) community.users.add(user) return community def update(self, community, validated_data): usersData = validated_data.pop('users') community.name = validated_data['name'] users_list = [] for user in usersData: user, created = User.objects.get_or_create( username=user['username'], email=user['email'], first_name=user['first_name'], last_name=user['last_name'], password=user['password']) users_list.append(user) community.users.set(users_list) community.save() return community def validate(self, data): value = data['name'] if (value == '') or (len(value) > 30) or (" " in value) or value.isspace(): raise serializers.ValidationError("Community name invalid") return data
class ProjectShortSerializer(serializers.ModelSerializer): creator = UserSerializer(read_only=True) status_name = serializers.SerializerMethodField class Meta: model = models.Project fields = ('id', 'name', 'status', 'creator') def validate_status(self, value): if value > 3 or value < 1: raise serializers.ValidationError('Project status must be between 1 and 3') return value def validate_id(self, value): if value > 0: raise serializers.ValidationError('Project status must be geater than 0') return value
def signup(self, request, **kwargs): serializer = UserSerializer(data=request.data) if serializer.is_valid(): password = PasswordSerializer(data=request.data) if password.is_valid(): user = serializer.save() password = password.save() user.password = password user.save() payload = api_settings.JWT_PAYLOAD_HANDLER(user) response_data = { "user": self._get_shallow_user_info(serializer), "token": api_settings.JWT_ENCODE_HANDLER(payload) } return Response(response_data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs): user = request.user new_data = request.data.get('new_data', {}) password_changed = {} if 'password' in new_data: user.set_password(new_data.pop('password')) password_changed = {'password': '******'} serializer = UserSerializer(user, data=new_data, partial=True) if serializer.is_valid(): serializer.save() return Response({**serializer.data, **password_changed}) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)