def test_field_to_native_request_POST(self): request = Request(self.factory.post('/')) mock_serializer = Serializer() mock_serializer.context = {'request': request} field = TranslationSerializerField() field.initialize(mock_serializer, 'name') self._test_expected_dict(field)
def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = set(ctx.get("columns", [])) queries = ctx.get("queries", []) if ctx.get('minimal'): for fn in list(self.fields): if fn != 'id' and fn not in columns: del self.fields[fn] for column in columns: if column not in self.fields: self.fields[column] = CharField() if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "projectid" in columns: self.fields['projectid'] = IntegerField() if "lead" in columns: self.fields['lead'] = HighlightField() if "kwic" in columns: self.fields['left'] = KWICField(kwic='left') self.fields['keyword'] = KWICField(kwic='keyword') self.fields['right'] = KWICField(kwic='right')
def test_field_to_native_request_GET(self): request = Request(self.factory.get('/')) mock_serializer = Serializer() mock_serializer.context = {'request': request} field = self.field_class() field.initialize(mock_serializer, 'name') self._test_expected_dict(field)
def post(self, request): Serializer = UserSerializer(data=request.data) if Serializer.is_valid(raise_exception=True): Serializer.save() # generate a token and login email = request.data['email'] password = request.data['password'] user = User.objects.filter(email=email).first() payload = { 'id': user.id, 'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=60), 'iat': datetime.datetime.utcnow() } token = jwt.encode(payload, 'secret',algorithm='HS256').decode('utf-8') response = Response({}, status=status.HTTP_200_OK) response.set_cookie(key='jwt', value=token, httponly=True) response.data = { 'jwt': token, 'id': user.id } return response return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_field_to_native_request_GET(self): request = Request(self.factory.get("/")) mock_serializer = Serializer() mock_serializer.context = {"request": request} field = TranslationSerializerField() field.initialize(mock_serializer, "name") self._test_expected_dict(field)
def register(s, f): Serializer = serializers.LoginSerializer(data=f.POST) if Serializer.is_valid(raise_exception=True): Serializer.save() return response.Response(Serializer.data) else: return response.Response(Serializer.errors)
def test_moves_field_under_new_name(self): serializer = Serializer() field = CharField() serializer.fields['foo'] = field rename_serializer_field(serializer, 'foo', 'bar') with self.assertRaises(KeyError): _ = serializer.fields['foo'] self.assertEqual(field, serializer.fields['bar'])
def post(self, request, format='json'): Serializer = UserSerializer(data=request.data) #serializer object if Serializer.is_valid(): user = Serializer.save() if user: return Response(Serializer.data, status=status.HTTP_201_CREATED) return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST) #handles the bad request
def perform_create(self, serializer: Serializer): if serializer.is_valid(): password = serializer.validated_data.get('password') new_user = serializer.save() new_user.set_password(password) new_user.save() return Response(serializer.data, status.HTTP_201_CREATED) super().perform_create(serializer)
def post(self, request, user_id, advisor_id): recieved_data = request.data recieved_data["advId"] = advisor_id recieved_data["userId"] = user_id Serializer = BookingSerializer(data=recieved_data) if Serializer.is_valid(): Serializer.save() return Response(None, status=status.HTTP_200_OK) return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): Serializer = AdvisorSerializer(data=request.data) if Serializer.is_valid(): Serializer.save() test_res = {} test_res["name"] = Serializer.data["name"] test_res["picture_url"] = Serializer.data["picture_url"] return Response(test_res, status=status.HTTP_200_OK) return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def generic_verify_url(self): serializer = Serializer(settings.SECRET_KEY, 3600) # 加载用户信息 token = serializer.dumps({'user_id': self.id, 'email': self.email}) # 注意拼接的过程中对 token进行decode操作 verify_url = 'http://www.meiduo.site:8080/success_verify_email.html?token=' + token.decode() return verify_url
def perform_create(self, serializer: Serializer) -> None: try: message, signature = extract_authorization_components(self.request) address = extract_address_from_authorization(message, signature) except Exception: logger.exception('Failure processing credentials') raise APIException('Invalid credentials') if serializer.validated_data['address'] != address: raise ValidationError('Addresses do not match') serializer.save()
def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = ctx.get("columns", []) queries = ctx.get("queries", None) if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "lead" in columns: self.fields['lead'] = HighlightField()
def perform_update(self, serializer: Serializer): serializer.is_valid(raise_exception=True) if serializer.validated_data['is_default']: # default may change previous_instance = self.get_object() # Currency if not previous_instance.is_default: # default currency is changing, adjusting exchange rates rate_to_old_default = previous_instance.rate for currency in Currency.objects.all(): currency.rate = currency.rate / rate_to_old_default currency.is_default = currency.code == previous_instance.code currency.save() else: super().perform_update(serializer)
def extract_id_field(self, fields, serializer: serializers.Serializer): # Included in fields and explicitly named "id" if 'id' in fields: serializer_id = fields['id'] model_pk = get_serializer_model_primary_key(serializer) if model_pk and model_pk.name != 'id' and get_field_by_source( fields.values(), model_pk.name): raise JSONAPIDeclarationError( 'if serializer includes primary key it cannot define other field as id' ) return serializer_id if not isinstance(serializer, serializers.ModelSerializer): return None # Included in fields, but not as "id", find by model primary key model_pk = get_serializer_model_primary_key(serializer) serializer_id = get_field_by_source(fields.values(), model_pk.name) if serializer_id: return serializer_id # Not included in fields, create "temporary" field based on model primary key id_field_class, id_field_kwargs = serializer.build_standard_field( 'id', model_pk) serializer_id: serializers.Field = id_field_class( **id_field_kwargs, source=model_pk.name if model_pk.name != 'id' else None) # NOTE: emulating binding, this is one-way binding # This field is safe to use and pass anywhere, but it won't be visible from serializer serializer_id.bind('id', serializer) return serializer_id
def api_paging(objs, request, Serializer): """ objs : 实体对象 request : 请求对象 Serializer : 对应实体对象的序列化 """ try: page_size = int(request.GET.get('page_size', 2)) page = int(request.GET.get('page', 1)) except (TypeError, ValueError): return JsonResponse( code=status.HTTP_400_BAD_REQUEST, desc='page and page_size must be integer!' ) paginator = Paginator(objs, page_size) # paginator对象 total = paginator.num_pages #总页数 try: objs = paginator.page(page) except PageNotAnInteger: objs = paginator.page(1) except EmptyPage: objs = paginator.page(paginator.num_pages) serializer = Serializer(objs, many=True) #序列化操作 return JsonResponse( data={ 'detail': serializer.data, 'page': page, 'total': total }, code=status.HTTP_200_OK, desc='page success' ) #返回
def test_field_to_native_request_GET_lang(self): """ Pass a lang in the query string, expect to have a single string returned instead of an object. """ # Note that we don't go through the middlewares etc so the actual # language for the process isn't changed, we don't care as # _expect_single_string() method simply tests with the current language, # whatever it is. request = Request(self.factory.get('/', {'lang': 'lol'})) eq_(request.GET['lang'], 'lol') mock_serializer = Serializer() mock_serializer.context = {'request': request} field = self.field_class() field.initialize(mock_serializer, 'name') self._test_expected_single_string(field)
def setUp(self): self.field = UserField() self.serializer = Serializer(context={ 'request': APIRequestFactory().get('/'), }) self.field.bind('user', self.serializer) self.user = UserFactory()
def test_field_to_native_request_GET_lang(self): """ Pass a lang in the query string, expect to have a single string returned instead of an object. """ # Note that we don't go through the middlewares etc so the actual # language for the process isn't changed, we don't care as # _expect_single_string() method simply tests with the current language, # whatever it is. request = Request(self.factory.get("/", {"lang": "lol"})) eq_(request.GET["lang"], "lol") mock_serializer = Serializer() mock_serializer.context = {"request": request} field = TranslationSerializerField() field.initialize(mock_serializer, "name") self._test_expected_single_string(field)
def test_field_to_native_request_GET_lang(self): """ Pass a lang in the query string, expect to have a single string returned instead of an object. """ # Note that we don't go through the middlewares etc so the actual # language for the process isn't changed, we don't care as # _expect_single_string() method simply tests with the current # language, whatever it is. request = Request(self.factory.get('/', {'lang': 'lol'})) eq_(request.GET['lang'], 'lol') mock_serializer = Serializer() mock_serializer.context = {'request': request} field = self.field_class() field.initialize(mock_serializer, 'name') self._test_expected_single_string(field)
def horseview(request, horsename=None): try: horse_ = de_sluggify(horsename) queryset = Horse.objects.filter(horses__contains=[horse_]) serializer = Serializer(queryset, many=True) return Response(serializer.data) except: raise Http404("Whoops... Try again")
def predict_results(request, pk=None): race = get_object_or_404(Horse.objects.filter(category='TCR', pk=pk)) try: race.results = RacePredictor(race.horses) serializer = Serializer(race, many=False) except: raise Http404("Whoops... try again") return Response(serializer)
def get_last_message(self, instance): try: last_message = instance.messages.select_related('user', 'chat').prefetch_related('images', 'user__images')\ .latest('date_created') except Message.DoesNotExist: last_message = None return MessageSerializer( last_message).data if last_message else Serializer(None).data
def generic_user_info(self,token): serializer = Serializer(settings.SECRET_KEY, 3600) try: result = serializer.loads(token) except BadData: return None else: id = result.get('id') email = result.gte('email') try: user = User.objects.grt(id=id,email=email) except User.DoesNotExist: return None else: return user
def to_representation(self, instance): """flatten recipe""" recipe = Serializer.to_representation(self, instance) if 'ingredients' in recipe: flattened_recipe = dict(**recipe['recipe'], ingredients=recipe['ingredients']) else: flattened_recipe = dict(**recipe['recipe']) return flattened_recipe
def results(request, pk=None): try: race = get_object_or_404(Race.objects.all(), pk=pk) assert (race['category'] in ['Pre', 'Past']) except: raise Http404("We don't have results for that race") serializer = Serializer(race, many=False) return Response(serializer.data)
def category(request, cat=None): try: assert (cat in Race.CATEGORY_CHOICES) except: raise Http404("Whoops... Try again") else: queryset = Race.objects.filter(category=cat) serializer = Serializer(queryset, many=True) return Response(serializer.data)
def from_serializer( serializer: serializers.Serializer, api_type: str, *, id_field: str = "", **kwargs: Any, ) -> Type[ResourceObject]: """ Generate a schema from a DRF serializer. :param serializer: The serializer instance. :param api_type: The JSON API resource type. :param id_field: The 'id" field of the resource. If left empty, it is either "id" for non-model serializers, or for model serializers, it is looked up on the model. :param kwargs: Extra options (like links and transforms) passed to the schema. :return: The new schema class. """ # get_fields() should return them in the order of Meta.fields serializer_name = type(serializer).__name__ attrs: List[str] = [] rels: List[str] = [] if not id_field: # If this is a model serializer, we can reach in to the model # and look for the model's PK. if isinstance(serializer, serializers.ModelSerializer): model = serializer.Meta.model for db_field in model._meta.get_fields(): if getattr(db_field, "primary_key", False): id_field = db_field.attname break if not id_field: raise ValueError( f"Unable to find primary key from model: {model}") else: # Otherwise, just assume it's "id" id_field = "id" for field_name, field in serializer.get_fields().items(): if field_name != id_field: if isinstance(field, serializers.RelatedField): rels.append(field_name) else: attrs.append(field_name) values: Dict[str, Any] = { "id": id_field, "type": api_type, "attributes": attrs, "relationships": rels, } values.update(**kwargs) return type(f"{serializer_name}_AutoSchema", (ResourceObject, ), values)
def perform_update(self, serializer: Serializer) -> None: instance = serializer.save() if not self.AUDITOR_EVENT_TYPES: return instance event_type = self.AUDITOR_EVENT_TYPES.get('UPDATE') if event_type and is_user(self.request.user): auditor.record(event_type=event_type, instance=instance, actor_id=self.request.user.id, actor_name=self.request.user.username)
def to_internal_value(self, data): """split into recipe and ingredients""" new_recipe = { 'recipe': { key: value for (key, value) in data.items() if key != 'ingredients' } } if 'ingredients' in data: new_recipe['ingredients'] = data['ingredients'] return Serializer.to_internal_value(self, new_recipe)
def perform_update(self, serializer: Serializer): if serializer.is_valid(raise_exception=True): previous_instance = self.get_object() # type: Domain registration_period = serializer.validated_data[ 'registration_period'] if registration_period and registration_period != previous_instance.registration_period: # registration period changed, update price cycle service = previous_instance.service new_cycle = service.product.cycles.filter( cycle_multiplier=registration_period).first() if new_cycle: service.cycle = new_cycle service.save() else: raise ValidationError({ 'registration_period': _('No price defined for this registration period. Check TLD pricing' ) }) new_name = serializer.validated_data['name'] if new_name and new_name != previous_instance.name: if not DomainUtils.validate_domain_name(domain_name=new_name): raise ValidationError({'name': _('Invalid domain name')}) try: new_tld_name = DomainUtils.get_tld_name(new_name) except ValueError: new_tld_name = None if previous_instance.tld.name != new_tld_name: raise ValidationError({ 'name': _('New domain name should have the same TLD({})'). format(previous_instance.tld.name) }) serializer.save()
def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = set(ctx.get("columns", [])) if not columns: columns = self.default_columns queries = ctx.get("queries", []) if ctx.get('minimal'): for fn in list(self.fields): if fn != 'id' and fn not in columns: del self.fields[fn] for column in columns: if column not in self.fields: self.fields[column] = CharField() if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "date" in columns: self.fields['date'] = DateTimeField(input_formats=("iso-8601",)) if "projectid" in columns: self.fields['projectid'] = IntegerField() if "lead" in columns: self.fields['lead'] = HighlightField() if "kwic" in columns: self.fields['left'] = KWICField(kwic='left') self.fields['keyword'] = KWICField(kwic='keyword') self.fields['right'] = KWICField(kwic='right')
def _get_serializers_to_check( include_apps: Optional[Iterable[str]] = None, ) -> Tuple[Iterator[Type[Serializer]], Iterator[Type[ModelSerializer]]]: serializer_classes = _filter_app_serializers( _collect_serializers(s for s in Serializer.__subclasses__() if s is not ModelSerializer # type: ignore ), include_apps, ) model_serializer_classes = _filter_app_serializers( _collect_serializers(ModelSerializer.__subclasses__()), include_apps) return ( serializer_classes, cast(Iterator[Type[ModelSerializer]], model_serializer_classes), )
def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = ctx.get("columns", []) queries = ctx.get("queries", []) if ctx.get('minimal'): for fn in list(self.fields): if fn != 'id' and fn not in list(columns): del self.fields[fn] if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "projectid" in columns: self.fields['projectid'] = IntegerField() if "lead" in columns: self.fields['lead'] = HighlightField() if "kwic" in columns: self.fields['left'] = KWICField(kwic='left') self.fields['keyword'] = KWICField(kwic='keyword') self.fields['right'] = KWICField(kwic='right')
def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) for x in kwargs["context"]["axes"]: self.fields[x] = CharField()
def test_field_to_native_empty_context(self): mock_serializer = Serializer() mock_serializer.context = {} field = self.field_class() self._test_expected_dict(field, mock_serializer)
def test_field_to_native_request_POST(self): request = Request(self.factory.post('/')) mock_serializer = Serializer() mock_serializer.context = {'request': request} field = self.field_class() self._test_expected_dict(field)
def test_field_to_native_empty_context(self): mock_serializer = Serializer() mock_serializer.context = {} field = TranslationSerializerField() field.initialize(mock_serializer, "name") self._test_expected_dict(field)
def test_get_attribute_empty_context(self): mock_serializer = Serializer() mock_serializer.context = {} field = self.field_class() self._test_expected_dict(field, mock_serializer)
def test_get_attribute_request_GET(self): request = Request(self.factory.get('/')) mock_serializer = Serializer() mock_serializer.context = {'request': request} field = self.field_class() self._test_expected_dict(field)
def test_field_to_native_empty_context(self): mock_serializer = Serializer() mock_serializer.context = {} field = self.field_class() field.initialize(mock_serializer, 'name') self._test_expected_dict(field)