def post(self, request): serializer = UserSerializer(data=request.data) #en rest framework los datos que se envían están en data, y no en POST if serializer.is_valid(): serializer.save() return Response(serializer.data, status=HTTP_201_CREATED) else: return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def create(self, req): serializer = UserSerializer(data=req.data, context={'request': req}) if serializer.is_valid(): new_user = serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None): my_profile = request.user.get_profile() # User should be able to edit first_name, last_name, email here # TODO: Make sure this is safe as we are making two calls to serialize the request user_serializer = UserSerializer( request.user, data=request.DATA, partial=True ) if not user_serializer.is_valid(): return errors.New400BadRequest(user_serializer.errors) user_serializer.save() serializer = ProfileSerializer( my_profile, data=request.DATA, partial=True ) print serializer.errors if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) return errors.New400BadRequest(serializer.errors)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): new_user = serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, userid): user = self.get_user(userid) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): request_data = request.data client_data = request_data["client"] try: client = Client.objects.get(user__email=client_data["user"]["email"]) user_serializer = UserSerializer(client.user, data=client_data["user"]) except Client.DoesNotExist: client = None user_serializer = UserSerializer(data=client_data["user"]) # Update information for user. if user_serializer.is_valid(): user_serializer.save() else: return Response(user_serializer.errors) del client_data["user"] client_data["user_id"] = user_serializer.instance.id # Update information for client. if client: serializer = ClientSerializer(client, data=client_data) else: serializer = ClientSerializer(data=client_data) if serializer.is_valid(): serializer.save() # Add this client to the provision table. users_db_utils.add_to_client_provision( serializer.instance.id) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors)
def create(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): new_user = serializer.save() send_mail(u"Bienvenido!", u"Bienvenido a Frikr!", "*****@*****.**", [new_user.email], fail_silently=True) return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk): user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) # llama a has_object_permission serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=HTTP_202_ACCEPTED) else: return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def update(self, request, pk): user = get_object_or_404(User, pk=pk) # Paso al serializados que instancia y con que la tiene que actualizar. serializer = UserSerializer(instance=user, data=request.data) 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)
class UpdateUserTest(APITestCase): def setUp(self): self.user = User.objects.create(username="******", first_name="Jake") self.data = UserSerializer(self.user).data self.data.update({'first_name': 'Changed'}) def test_can_update_user(self): response = self.client.put(reverse('user-detail', args=[self.user.id]), self.data) self.assertEqual(response.status_code, status.HTTP_200_OK)
def put(self, request, pk): user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) serializer = UserSerializer(User, request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) else: return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
def create(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): new_user = serializer.save() # Devolvemos los datos después de crear el recurso, es como un acuse de recibo. # no todas las apis devuelven los datos. return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk): user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) # compruebo si el usuario autenticado puede hacer PUT en este user serializer = UserSerializer(instance=user, data=request.data) 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 update(self, req, pk): user = get_object_or_404(User, pk=pk) self.check_object_permissions(req, user) # permisos a mano serializer = UserSerializer(instance=user, data=req.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) else: return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def update(self, request, pk): self.check_permissions(request) user = get_object_or_404(User, pk=pk) self.check_object_permissions(request, user) serializer = UserSerializer(instance=user, data=request.data) #Serializa este usuario con data datos 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 put(self, request, pk): user = get_object_or_404(User, pk=pk) if request.user.is_superuser or request.user.username == user.username: serializer = UserSerializer(instance=user, data=request.data) 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) else: return Response(status=status.HTTP_401_UNAUTHORIZED)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): new_user = serializer.save() blog = Blog() blog.title = request.data.get("blog") blog.owner = new_user blog.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def list_matches(self, request): serialized = UserSerializer(data=request.data) if serialized.is_valid(): User.objects.create_user( serialized.init_data['email'], serialized.init_data['date_of_birth'], serialized.init_data['password'] ) return Response(serialized.data, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) # se inicializa el serializer con los datos que me llegan por http mediante POST if serializer.is_valid(): new_user = serializer.save() # Guarda el objeto en BB.DD. y me lo devuelve new_blog = Blog() new_blog.name = 'El blog de {0} {1}'.format(request.data.get('first_name'), request.data.get('last_name')) new_blog.author = new_user new_blog.save() # serializer almacena los datos en 'serializer.data' return Response(serializer.data, status=status.HTTP_201_CREATED) else: # serializer almacena los errores en 'serializer.errors' return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk): user = get_object_or_404(User, pk=pk) # devuelve el objeto o, si este no existe, un error 404 # compruebo si el usuario autenticado puede hacer PUT en este user # Hay que hacerlo a mano porque estamos heredando de una GenericAPIView # Al hacer la recuperación del objeto 'user' manualmente, la comprobacion tambien debe ser manual self.check_object_permissions(request, user) serializer = UserSerializer(instance=user, data=request.data) 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 create(self, request): serializer = UserSerializer(data=request.data) #TODOS LOS MÉTODOS REST VIENEN POR EL PARAMETRO 'DATA' DE LA REQUEST if serializer.is_valid(): new_user = serializer.save() # TODO - crear el usuario y su blog en una sóla llamada blog_for_newUser = Blog() blog_for_newUser.owner = new_user blog_for_newUser.name = new_user.first_name + ' ' + new_user.last_name + '\'s Personal Blog' blog_for_newUser.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_auth(request): serialized = UserSerializer(data=request.data) if request.data['secret_code'] == settings.SECRET_CODE: if serialized.is_valid(): User.objects.create_user( serialized.data['username'], serialized.data['email'], serialized.data['password'] ) return Response(serialized.data, status=status.HTTP_201_CREATED) else: return Response(serialized._errors , status=status.HTTP_400_BAD_REQUEST) else: return Response({'Incorrect inscription code' : [", please contact our team to get yours"]} , status=status.HTTP_400_BAD_REQUEST)
def test_user_creation(self): data = {"username": "******", "email": "*****@*****.**", "password": "******", "first_name": "tester", "last_name": "testington"} serializer = UserSerializer(data=data) self.assertTrue(serializer.is_valid(), msg=serializer.errors) user = serializer.create(serializer.validated_data) self.assertEqual(data['username'], user.username) self.assertEqual(data['email'], user.email) self.assertEqual(data['first_name'], user.first_name) self.assertEqual(data['last_name'], user.last_name)
def put(self, request, pk): """ Endpoint de modificación de usuario. Por convención, se utiliza la url de listado con una petición PUT para la modificación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instancia del User; si la tiene, coge esa instancia y llama al update() del serializer; si no la tiene, llama al método create() del serializer, como en el caso del POST del UserListAPI """ user = get_object_or_404(User, pk=pk) # compruebo manualmente si el usuario autenticado puede hacer PUT en este user self.check_object_permissions(request, user) # Actualiza los datos de la instancia recuperada con los datos que me pasan por la API serializer = UserSerializer(instance=user, data=request.data) 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 invite(self, request, pk=None): user_invite_serializer = UserSerializer( data=request.data) # Process user and check if it was already in our system user, created = user_invite_serializer.process_new_user( request, force_invite=True) if created: rstatus = status.HTTP_201_CREATED elif user: rstatus = status.HTTP_200_OK else: rstatus = status.HTTP_400_BAD_REQUEST return Response(UserSerializer(instance=user).data, status=rstatus)
def create(self, request): """ Endpoint de creación de usuario. Guardamos automáticamente también el blog con su nombre de usuario :param request: :return: """ # Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST, # request.GET, etc., se utiliza simplemente data serializer = UserSerializer(data=request.data) if serializer.is_valid(): new_user = serializer.save() # Guardamos blog para el nuevo usuario user_blog = Blog() user_blog.owner = new_user user_blog.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): """ Endpoint de creación de usuario. Por convención, se utiliza la url de listado con una petición POST para la creación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instasncia del User; si no la tiene, llama al método create del serializer. """ # Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST, # request.GET, etc., se utiliza simplemente data serializer = UserSerializer(data=request.data) if serializer.is_valid(): # Guardamos el usuario a través del serializer y devolvemos los datos del objeto creado new_user = serializer.save() # Guardamos blog para el nuevo usuario user_blog = Blog() user_blog.owner = new_user user_blog.save() # Respondemos código 201 (creado) y los datos del objeto creado return Response(serializer.data, status=status.HTTP_201_CREATED) else: # Devolvemos diccionario con errores y el código 400 (petición errónea) si algo fue mal return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk): """ Retrieve, update or delete a user instance. """ try: user = User.objects.get(pk=pk) except User.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = UserSerializer(user) return Response(serializer.data) elif request.method == 'PUT': serializer = UserSerializer(user, data=request.DATA) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': user.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, username, format=None): data = UserAccountSerializer(data=request.data).data user = User.objects.get(username=username) user_serializer = UserSerializer(user, data=data['user']) if user_serializer.is_valid(): user_serializer.save() account = self.get_object(username) account.school = data.get('school') account.class_in_school = data.get('class_in_school') # client should put facebook_id to enable this # account.facebook_id = data.get('facebook_id') account.save() update_session_auth_hash(request, user) return Response(UserAccountSerializer(account).data) return Response(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, username, format=None): serializer = UserAccountSerializer(data=request.data) if serializer.is_valid() is False: return Response( {"message": "Cannnot update profile with provided information"}, status=status.HTTP_400_BAD_REQUEST ) data = serializer.validated_data password = data["user"].get("password") confirm_password = data["user"].get("confirm_password") if password != confirm_password: return Response( {"message": "Password and confirm password don't match"}, status=status.HTTP_400_BAD_REQUEST ) user = User.objects.get(username=username) user_serializer = UserSerializer(user, data=data["user"]) if user_serializer.is_valid(): user_serializer.save() account = self.get_object(username) account.school = data.get("school") account.class_in_school = data.get("class_in_school") # client should put facebook_id to enable this # account.facebook_id = data.get('facebook_id') account.save() update_session_auth_hash(request, user) return Response(UserAccountSerializer(account).data) return Response(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ReviewSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) region = RegionSerializer(many=True, source="region_reivews", required=False) subject = SubjectSerializer(many=True, source='subject_reivews', required=False) activity = ActivitySerializer(many=True, required=False) comments = CommentSerializer(many=True, required=False) images = ImageSerializer(many=True, required=False) class Meta: model = Review fields = [ 'id', 'title', 'body', 'created_at', 'updated_at', 'user', 'region', 'subject', 'activity', 'comments', 'like_count', 'images' ] def create(self, validated_data): try: subject_data = validated_data.pop('subject') activity_data = validated_data.pop('activity') regions_data = validated_data.pop('region') review = Review.objects.create(**validated_data) for data in regions_data: region, created = Region.objects.get(city=data['city'], town=data['town']) review.region.add(region) for data in activity_data: activity = Activity.objects.get(id=data['id']) review.activity.add(activity) for data in subject_data: subject, created = Subject.objects.get(id=data['id']) review.subject.add(subject) except: review.delete() finally: return review
def get_delete_update_user(request, pk): user = get_object_or_404(User, pk=pk) # get details of a single user if request.method == 'GET': serializer = UserSerializer(user) return Response(serializer.data) # delete a single user elif request.method == 'DELETE': user.delete() return Response(status=status.HTTP_204_NO_CONTENT) # update details of a single user elif request.method == 'PUT': serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_204_NO_CONTENT) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class OrderEventSerializer(serializers.ModelSerializer): owner = UserSerializer(read_only=True) rate_cards = PrimaryKeyRelatedField(allow_empty=True, many=True, queryset=RateCard.objects.all(), required=False) participants = PrimaryKeyRelatedField(allow_empty=True, many=True, queryset=User.objects.all(), required=False) status = SerializerMethodField() class Meta: model = OrderEvent fields = ('id', 'name', 'owner', 'rate_cards', 'participants', 'status') depth = 1 def get_status(self, status) -> str: return status.get_status_display()
class LeaseAreaAttachmentSerializer(FileSerializerMixin, EnumSupportSerializerMixin, 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 = LeaseAreaAttachment fields = ('id', 'type', 'file', 'filename', 'uploader', 'uploaded_at', 'lease_area') download_url_name = 'leaseareaattachment-download' def override_permission_check_field_name(self, field_name): if field_name == 'filename': return 'file' return field_name
def isLogin(request): if request.user.is_authenticated(): likes = list() for like in Like.objects.filter(user=request.user): likes.append(like.blog.id) return http.JsonResponse({ 'user': UserSerializer(request.user, context={ 'request': request }).data, 'user_extend': UserExtendSerializer(request.user.userextend, context={ 'request': request }).data, 'like': likes, }) else: return http.HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
def post(self, *args, **kwargs): serializer = UserAuthTokenSerializer(data=self.request.data) if serializer.is_valid(): if self.request.META.get('HTTP_AUTHORIZATION').split(' ')[1] != serializer.validated_data.get('token'): return Response({ 'error': 'Invalid authorization token!', }) try: token = Token.objects.get(key=serializer.validated_data.get('token')) user = User.objects.get(phone=token.user) except Token.DoesNotExist: return Response({ 'error': 'User with this token does not exist!', }, status=status.HTTP_404_NOT_FOUND) return Response({ 'user': UserSerializer(user).data, }, status=status.HTTP_200_OK) return Response({ 'error': 'Token is required!', }, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk=None): if pk: error = {"errors": "Must Not Include id while making PUT request"} return Response(error, status=status.HTTP_400_BAD_REQUEST) print("Inside Post") try: user = User.objects.all().get(id=request.data["id"]) except ObjectDoesNotExist: user_dict = request.data.dict() print(type(user_dict)) user_dict["password"] = bcrypt.hashpw( user_dict["password"].encode("utf-8"), bcrypt.gensalt((15))) print(user_dict) new_user = User(**user_dict) new_user.save() print(new_user.password) serializer = UserSerializer(new_user) return Response(serializer.data) error = {"errors": "User Id already exists "} return Response(error, status=status.HTTP_400_BAD_REQUEST)
class PostListSerializer(ModelSerializer): url = HyperlinkedIdentityField( view_name='blog_api:detail', lookup_field='slug' ) user = UserSerializer(read_only=True) class Meta: model = Post fields = [ 'user', 'id', 'url', 'slug', 'title', 'description', 'image', 'category', 'timestamp', ]
class RoomSerializer(serializers.ModelSerializer): user = UserSerializer() class Meta: model = Room exclude = ("modified", ) read_only_fields = ("user", "id", "created", "updated") def validate(self, data): if self.instance: check_in = data.get("check_in", self.instance.check_in) check_out = data.get("check_out", self.instance.check_out) else: check_in = data.get("check_in") check_out = data.get("check_out") if check_in == check_out: raise serializers.ValidationError( "Not enough time between changes") return data
def create(self, request, *args, **kwargs): client = User.objects.get(email=request.data.get('client')) service_provider = Business.objects.get( pk=request.data.get('service_provider')) service_type = Service.objects.get(pk=request.data.get('service_type')) appointment_data = { 'client': UserSerializer(client).data, 'service_provider': BusinessSerializer(service_provider).data, 'time': request.data.get('time'), 'date': request.data.get('date'), 'service_type': ServiceSerializer(service_type).data, 'comment': request.data.get('comment'), } serializer = AppointmentSerializer(data=appointment_data) serializer.is_valid(raise_exception=True) self.perform_create(serializer) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def to_representation(self, instance): data = super().to_representation(instance) request = self.context.get("request") data['user'] = UserSerializer(User.objects.get(pk=data['user']), context={ 'request': request }).data if (data['tweet']): data['tweet'] = TweetSerializer( Tweet.objects.get(pk=data['tweet']), context={ 'request': request }).data if (data['retweet']): data['retweet'] = RetweetSerializer( Retweet.objects.get(pk=data['retweet']), context={ 'request': request }).data return data
def register_user(request): print("Creating a new user") print(request.data) data = {'username':request.data["userName"], 'password':request.data["password"], 'email':request.data["email"]} serializer = UserSerializer(data=data) if serializer.is_valid(): print("Valid") user = serializer.save() # have to create profile data and link it to user data = {'user':user, 'first_name':None, 'last_name':None, 'email':request.data["email"], 'birth_date':None, 'country':None} serializer = ProfileSerializer(data=data) if serializer.is_valid(): print("Profile data is valid") serializer.save() else: print("Profile data is not valid") print(serializer.errors) #profile = Profile(user=user, first_name=None, last_name=None, email=request.data["email"], birth_date=None, country=None) return Response({'user': serializer.data}) print("data not valid") print(serializer.errors)
class ObtainTokenSerializer(serializers.Serializer): email = serializers.EmailField(required=True, write_only=True) password = serializers.CharField(max_length=256, required=True, write_only=True) token = serializers.CharField(max_length=256, read_only=True) user = UserSerializer(read_only=True) def validate(self, attrs): credentials = { "email": attrs.get("email", None), "password": attrs.get("password", None), } user = authenticate(**credentials) payload = jwt_payload_handler(user) token = jwt_encode_handler(payload) return jwt_response_payload_handler(user=UserSerializer(user).data, token=token)
def post(self, request): login_serializer = UserLoginSerializer( data=request.data.get('login_data')) login_serializer.is_valid(raise_exception=True) user = login_serializer.validated_data.get('user') if user: login(request, user) user_serializer = UserSerializer( user, context={ 'data': { 'fields': ['first_name', 'last_name', 'email', 'token'] } }) return Response({'success': True, 'user': user_serializer.data}) return Response({ 'success': False, 'error': "Unable to login with given credentials" })
def update_collaborators(request, repo_id): repo = get_object_or_404(Repository, pk=repo_id) signed_in_user = request.user.id if repo.user.id != signed_in_user: raise GeneralException("Not authorized") user_id_list = request.data if len(user_id_list) > 0: repo.collaborators.clear() repo.collaborators.add(*user_id_list) else: repo.assignees.clear() repo.save() repo.refresh_from_db() serializer = UserSerializer(repo.collaborators, many=True) return Response(serializer.data)
def to_representation(self, instance): from events.serializers import EventItemSerializer, TransportationInfoSerializer response = super().to_representation(instance) data = { 'uuid': instance.uuid, 'event_item': EventItemSerializer(instance.event_item).data, 'item_master': ItemMasterSerializer(instance.item_master).data, 'user': UserSerializer(instance.user).data, 'event_attendee': EventAttendeeSerializer(instance.event_attendee).data, 'transportation_info': TransportationInfoSerializer(instance.transportation_info).data } response.update(data) return response
def retrieve(self, request, pk): """ Endpoint detalle de usuario :param request: :param pk: :return: """ # Si existe el usuario cuya PK=pk existe lo devuelve, y si no se captura una excepción y se manda # un código 404 # La función get_object_or_404 recibe el modelo como primer parámetro y a continuación los campos # de búsqueda user = get_object_or_404(User, pk=pk) # compruebo manualmente si el usuario autenticado puede hacer GET en este user self.check_object_permissions(request, user) # Convertimos objeto user en diccionario, que es guardado en 'data' serializer = UserSerializer(user) return Response(serializer.data)
def post(self, request, format=None): data = request.data username = data.get('username', None) password = data.get('password', None) account = authenticate(username=username, password=password) if account is not None: login(request, account) serialized = UserSerializer(account) return Response(serialized.data) else: return Response( { 'status': 'Unathorized', 'message': 'Lazy error message.' }, status=status.HTTP_401_UNAUTHORIZED)
class CommentSerializer(serializers.ModelSerializer): author = UserSerializer(required=False) class Meta: model = Comment fields = [ 'id', 'content_type_id', 'object_id', 'content', 'parent', 'created_at', 'author' ] def validate(self, data): parent = data.get('parent') # type: Optional[Comment] if parent: if data['content_type_id'] != parent.content_type_id or data[ 'object_id'] != parent.object_id: raise serializers.ValidationError( _("`content_type_id` and `object_id` should equal to parent's ones" )) return data
class LogEntrySerializer(serializers.ModelSerializer): class Meta: model = LogEntry fields = ( 'actor', 'object_repr', 'action', 'timestamp', 'changes', ) actor = UserSerializer() action = serializers.SerializerMethodField() changes = serializers.SerializerMethodField() def get_action(self, obj): return obj.get_action_display() def get_changes(self, obj): return obj.changes_dict
def get(self, request, *args, **kwargs): if IsLoggedIn(request): query_name = IsLoggedIn(request).username print(query_name) try: logger = Ngo.objects.get(username=query_name) except: logger = user.objects.get(username=query_name) if logger.IsNgo: serializer = NgoSerializer(logger) return Response(serializer.data, status=status.HTTP_206_PARTIAL_CONTENT) else: serializer = UserSerializer(logger) return Response(serializer.data, status=status.HTTP_206_PARTIAL_CONTENT) else: return Response({'message': "unauthenticated user"}, status=status.HTTP_401_UNAUTHORIZED)
class CommentCreateUpdateSerializer(serializers.Serializer): comment = CommentSerializer() auth_user = UserSerializer() def validate(self, data): for field in ('comment', 'auth_user'): if field not in data: raise serializers.ValidationError( _(f'`{field}` field is required')) return data def create(self, validated_data): author_data = validated_data.pop('auth_user') username = author_data.pop('username') user, _ = User.objects.get_or_create(username=username, defaults=author_data) comment = Comment.objects.create(author=user, **validated_data['comment']) comment_created.send(sender=comment.__class__, comment=comment, user=user) return { 'comment': comment, 'auth_user': user, } def update(self, instance, validated_data): instance.content = validated_data['comment']['content'] instance.save(update_fields=['content']) author_data = validated_data.pop('auth_user') username = author_data.pop('username') user, _ = User.objects.get_or_create(username=username, defaults=author_data) comment_updated.send(sender=instance.__class__, comment=instance, user=user) return { 'comment': instance, 'auth_user': user, }
def get_participants(self, request): username = request.data['email'] subject_slug = request.data['subject_slug'] user = User.objects.get(email = username) participants = None response = "" if not subject_slug == "": subject = Subject.objects.get(slug = subject_slug) participants = User.objects.filter(Q(is_staff = True) | Q(subject_student__slug = subject_slug) | Q(professors__slug = subject_slug) | Q(coordinators__subject_category__slug = subject_slug)).exclude(email = username).distinct() serializer = UserSerializer(participants, many = True, context = {"request_user": username}) json_r = json.dumps(serializer.data) json_r = json.loads(json_r) info = {} info["data"] = {} info["data"]["participants"] = json_r info["message"] = "" info["type"] = "" info["title"] = "" info["success"] = True info["number"] = 1 info['extra'] = 0 response = json.dumps(info) self.log_context['subject_id'] = subject.id self.log_context['subject_slug'] = subject_slug self.log_context['subject_name'] = subject.name super(ParticipantsViewset, self).createLog(user, self.log_component, self.log_action, self.log_resource, self.log_context) return HttpResponse(response)
class ObjectiveSerializer(serializers.ModelSerializer): """ The default serializer for a learning Objective. """ contributor = UserSerializer(required=False) num_questions = serializers.SerializerMethodField() class Meta: model = Objective fields = ( "id", "title", "specialty", "topic", "stage", "notes", "contributor", "created_at", "modified_at", "num_questions", ) read_only_fields = ( "id", "contributor", "created_at", "modified_at", "num_questions", ) def create(self, validated_data): """ Create a new objective, retrieving the user from the request. """ contributor = self.context["request"].user objective = Objective.objects.create(contributor=contributor, **validated_data) return objective def get_num_questions(self, object): """ Get the number of questions allocated under this objective. """ return object.objective_question.count()
class BlogSnippetSerializer(serializers.ModelSerializer): publisher_profile = UserSerializer(read_only=True) upvote = serializers.SerializerMethodField() downvote = serializers.SerializerMethodField() voted = serializers.SerializerMethodField() word_count = serializers.SerializerMethodField() def get_word_count(self, obj): line_soup = bs(obj.content.strip(), 'html.parser') # naive way to get words count words_count = len(line_soup.text.split()) return words_count def get_created_at(self, obj): if obj.date is None: return None return obj.date.astimezone(pytz.timezone('US/Pacific')) def get_upvote(self, obj): return models.Vote.objects.filter(blog=obj, vote_type=True).count() def get_downvote(self, obj): return models.Vote.objects.filter(blog=obj, vote_type=False).count() def get_voted(self, obj): voted = 0 user_vote = models.Vote.objects.filter(user=self.context.get('user'), blog=obj) if len(user_vote) > 0: if user_vote[0].vote_type: voted = 1 else: voted = -1 return voted class Meta: fields = ('id', 'publisher_profile', 'title', 'snippet', 'header_image', 'created_at', 'updated_at', 'view_count', 'upvote', 'downvote', 'word_count', 'voted', 'is_public', 'is_publish', 'is_approved') model = models.Blog
class CommentSerializer(serializers.ModelSerializer): poster = UserSerializer() community = CommunitySerializer() originalPost = PostSerializer() class Meta: model = Comment fields = [ 'post', 'community', 'poster', 'originalPost', 'originalPostId' ] def to_internal_value(self, data): internal_value = super(CommentSerializer, self).to_internal_value(data) ogpostid = data["originalPost"]["id"] internal_value.update({"ogpostid": ogpostid}) return internal_value def create(self, validated_data): print(validated_data) userData = validated_data.pop('poster') user = User.objects.get_or_create(username=userData['username'], email=userData['email'], first_name=userData['first_name'], last_name=userData['last_name'], password=userData['password'])[0] validated_data['poster'] = user communityData = validated_data.pop('community') community = Community.objects.get_or_create( name=communityData['name'])[0] validated_data['community'] = community originalPostData = validated_data.pop('originalPost') originalPost, created = Post.objects.get_or_create( id=validated_data['ogpostid']) validated_data['originalPost'] = originalPost validated_data['originalPostId'] = validated_data["ogpostid"] del validated_data["ogpostid"] comment = Comment.objects.create(**validated_data) return comment
class ProductReviewSerializer(serializers.ModelSerializer): product = ProductSerializer(read_only=True, ) user = UserSerializer(read_only=True, ) class Meta: model = ProductReview fields = ('id', 'user', 'product', 'text', 'rating', 'created_at', 'updated_at') def validate(self, data): if 'product_id' not in self.context[ 'request'].data: # Проверяем product_id raise serializers.ValidationError( 'product_id: This field is required.') product_id = self.context['request'].data['product_id'] if not isinstance(product_id, int): raise serializers.ValidationError('product_id should be integer') if not Product.objects.filter(id=product_id): raise serializers.ValidationError('Wrong product_id') user_id = self.context[ 'request'].user.id # Проверяем что отзыв на один продукт только один if ProductReview.objects.filter(user=user_id).filter( product=product_id): if self.context['request'].stream.method == 'POST': raise serializers.ValidationError( 'Maximum one review per user per product') elif self.context['request'].stream.method in ['PUT', 'PATCH']: if product_id != self.instance.product_id: raise serializers.ValidationError( "You already reviewed this product") return data def create(self, validated_data): """ Простановка значения поля user по-умолчанию и product по product.id""" validated_data['user'] = self.context['request'].user validated_data['product'] = Product.objects.get( id=self.context['request'].data['product_id']) return super().create(validated_data)
class RoomSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) photos = PhotoSerializer(read_only=True, many=True) is_fav = serializers.SerializerMethodField() class Meta: model = Room exclude = ("modified", ) read_only_fields = ( "user", "created", "updated", "id", ) def validate(self, data): if self.instance: check_in = data.get("check_in", self.instance.check_in) check_out = data.get("check_out", self.instance.check_out) else: check_in = data.get("check_in") check_out = data.get("check_out") if check_in == check_out: raise serializers.ValidationError( "Check-in and Check-out can't be set the same time") return data def get_is_fav(self, obj): request = self.context.get("request") if request: user = request.user if user.is_authenticated: return obj in request.user.favs.all() return False def create(self, validated_data): request = self.context.get("request") room = Room.objects.create(**validated_data, user=request.user) return room
def get_leaderboard_from_data(self, data, game_name): users = [] for raw_user_data in data: try: user = User.objects.get(phone=raw_user_data['phone']) except User.DoesNotExist: continue score = getattr(user.get_latest_scores(), game_name, None) if score is None: continue user_data = UserSerializer(user).data user_data['score'] = score users.append(user_data) if game_name == 'reaction_time': result = sorted(users, key=lambda k: k['score']) else: result = sorted(users, key=lambda k: -k['score']) return result
class DebitorListSerializer(ModelSerializer): balance = serializers.SerializerMethodField() user = UserSerializer() class Meta: model = EventAttendee exclude = ('updated_at', 'deleted_at',) def to_representation(self, instance): response = super().to_representation(instance) data = { 'user': UserSerializerWithNoDummyEmailAndPhone(instance.user, context={'event': self.context['event']}).data, } response.update(data) return response def get_balance(self, obj): from orders.utils import get_latest_order_of_main_user, get_net_positive_balance_credit_from_latest_order return get_net_positive_balance_credit_from_latest_order(get_latest_order_of_main_user(obj.user, obj.event))