def get(self, request, *args, **kwargs): query = Q(shop__state=True) shop_id = request.query_params.get('shop_id') category_id = request.query_params.get('category_id') product_id = request.query_params.get('product_id') if product_id: queryset = Product.objects.get(pk=product_id) serializer = ProductSerializer(queryset) else: if shop_id: query = query & Q(shop_id=shop_id) if category_id: query = query & Q(category_id=category_id) # фильтруем и отбрасываем дуликаты queryset = Product.objects.filter(query).select_related( 'shop', 'category').distinct() serializer = ProductSerializer(queryset, many=True) # .prefetch_related('product_parameters__parameter') return Response(serializer.data)
def put(self, request, pk, format=None): product = self.get_object(pk) serializer = ProductSerializer(product, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): serializer = ProductSerializer(data=request.data) if serializer.is_valid(): new_product = serializer.save() return Response(new_product) else: return Response(serializer.errors)
def update(self, request, *args, **kwargs): """ 제품 데이터 수정 """ product_id = request.data['id'] #json데이터를 객체로 역직렬화 product_data = json.loads(request.data['product']) file_list = request.FILES.getlist('photos') #업로드된 이미지 파일 저장 photo_urls = product_data["photo_urls"] photo_urls = photo_urls + \ self.__get_product_images(product_id, file_list) #원래 등록되어 있었던 이미지 목록 조회 original_images = \ ProductImage.objects.filter(product_id=product_id) #삭제된 이미지 삭제 처리 for oi in original_images: if oi.photo_url not in photo_urls: oi.delete() #새로 추가된 이미지 추가 self.__add_product_images(product_id, photo_urls) category_ids = product_data["category_ids"] #원래 등록되어 있었던 분류 목록 조회 original_categories =\ ProductCategory.objects.filter(product_id=product_id) #삭제된 분류 삭제 for oc in original_categories: if oc.category_id not in category_ids: oc.delete() #새로 추가된 분류 추가 self.__add_product_categories(product_id, category_ids) #제품 데이터 검증 및 모델 객체 생성 serializer = ProductSerializer(data=product_data) if serializer.is_valid(): validated_data = serializer.validated_data #모델에 포함되지 않은 속성은 삭제 del validated_data["category_ids"] #데이터에서 모델 객체 생성 product = Product(**serializer.validated_data) else: return Response(status=status.HTTP_400_BAD_REQUEST) #생성일은 변경하지 않도록 처리 del product.createdDate product.modifiedDate = datetime.now() product.save() return Response({"id": product.id})
class UserSerializer(UserCreateSerializer): cart = ProductSerializer(many=True, read_only=True) favorite = ProductSerializer(many=True, read_only=True) class Meta(UserCreateSerializer.Meta): model = User fields = [ 'id', 'first_name', 'last_name', 'email', 'number', 'password', 'image', 'username', 'bookmarks', 'favorite', 'cart' ]
def put(self, request, pk1, pk2): product = self.get_product(request, pk1, pk2) try: request.data.pop('category') except: pass serializer = ProductSerializer(instance=product, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors)
def get(cls, request, user_id, store_id) -> Response: import pdb pdb.set_trace() product_list = Product.objects.filter(store_id=store_id) products = cls.paginator.paginate_queryset(product_list, request) serializer = ProductSerializer(products, many=True) return cls.paginator.get_paginated_response(serializer.data)
class OrderItemSerializer(serializers.ModelSerializer): product = ProductSerializer(read_only=True) class Meta: model = OrderItem fields = ('id', 'product', 'price', 'quantity') read_only_fields = ('id',)
class WishListSerializer(serializers.ModelSerializer): product = ProductSerializer(many=True, read_only=True) class Meta: model = WishList fields = ['id', 'product'] depth = 1
class CartItemSerializer(serializers.ModelSerializer): product = ProductSerializer(read_only=True) color = ColorSerializer(read_only=True) size = SizeSerializer(read_only=True) class Meta: model = OrderItem fields = ['id', 'product', 'color', 'size', 'get_cost', 'quantity'] read_only_fields = ['id', 'get_cost', 'quantity']
def get_context_data(self, **kwargs): init_data = { 'SECTIONS': json.dumps(SectionSerializer(Section.objects.filter(is_active=True).order_by('order').prefetch_related('productsection_set'), many=True).data), 'PRODUCTS': json.dumps(ProductSerializer(Product.objects.all(), many=True).data), } kwargs.update(init_data) return super(IndexView, self).get_context_data(**kwargs)
def category_products(request, pk): try: category = Category.objects.get(id=pk) except Category.DoesNotExist as e: return JsonResponse({'error': str(e)}, safe=False) products = category.product_set.all() serializer = ProductSerializer(products, many=True) return JsonResponse(serializer.data, safe=False)
def create(self, request, *args, **kwargs): """ 제품 데이터 추가 """ #json데이터를 객체로 역직렬화 product_data = json.loads(request.data['product']) file_list = request.FILES.getlist('photos') #제품 데이터 검증 및 모델 객체 생성 serializer = ProductSerializer(data=product_data) if serializer.is_valid(): validated_data = serializer.validated_data #모델에 포함되지 않은 속성은 삭제 del validated_data["category_ids"] #데이터에서 모델 객체 생성 product = Product(**serializer.validated_data) else: return Response(status=status.HTTP_400_BAD_REQUEST) #생성일은, 수정일은 자동 입력되도록 처리 del product.created_date del product.modified_date product.save() #업로드된 이미지 파일 저장 photo_urls = product_data["photo_urls"] photo_urls = photo_urls + \ self.__get_product_images(product.id, file_list) #새로 추가된 이미지 추가 self.__add_product_images(product.id, photo_urls) category_ids = product_data["category_ids"] #새로 추가된 분류 추가 self.__add_product_categories( product.id, category_ids) return Response({ "id": product.id })
def get(self, request): searchword = request.GET.get('searchword') search_history = SearchHistory() search_history.seachword = searchword search_history.save() if searchword is not None: products = Product.objects.filter(name__icontains=searchword) else: products = Product.objects.all() data = ProductSerializer(products, many=True).data return Response(data)
def get( self, request, format=None, ): category_frontend_name = "" categoryId = request.GET.get('category', None) categorySlug = request.GET.get('category_slug', None) category = None if categoryId is not None: category = Category.objects.filter(id=convert_to_int(categoryId)) elif categorySlug is not None: category = Category.objects.filter(slug=categorySlug) if category is not None: category_name = [i for i in category.values_list("name")] print("category name:") print(category_name) if len(category_name) > 0: category_frontend_name = category_name[0][0] products = self.get_queryset(request) if products is None: return CustomJSONRenderer().render404('product', '') companySlug = request.GET.get('company_slug', None) dataCompany = None if companySlug: company = Company.objects.filter(slug=companySlug) if company.count() > 0: dataCompany = company.first() data = ProductSerializer( products, many=True, pop=['explanation_short', 'file', 'gallery', 'like'], context={ 'request': request }).data return CustomJSONRenderer().renderData( OrderedDict([('count', self.page.paginator.count), ('code_count', self.code_count), ('offer_count', self.offer_count), ('next', self.get_next_link()), ('previous', self.get_previous_link()), ('results', data), ('dataCompany', CompanySerializer(dataCompany, many=False, context={ 'request': request }, pop=['available']).data if dataCompany else None), ('category', category_frontend_name)]))
def favorite(request): """ API endpoint that allows users favorite product to be viewed. """ user_id = request.GET.get('user_id') print('-----------------------------came through-----------------------') try: user = User.objects.get(pk=int(user_id)) query_set = user.favorite.all() serializer = ProductSerializer(query_set, many=True) return Response(serializer.data) except User.DoesNotExist: return Response({'error': 'no user with that id'})
class OrderItemSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) order = OrderSerializer(read_only=True) product = ProductSerializer(required=True) quantity = serializers.IntegerField() def create(self, validated_data): return OrderItem.objects.create(**validated_data) def update(self, instance, validated_data): instance.quantity = validated_data.get('quantity', instance.quanity) instance.save() return instance
def post(cls, request, user_id, store_id) -> Response: try: serializer = ProductSerializer(data=request.data) if serializer.is_valid(raise_exception=True): product = serializer.save() return Response({"Product_id": product.id}, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) except IntegrityError: return Response({ "Error": "Invalid store id {} not exist.".format( int(request.data["store_id"])) }) except Exception: return Response({ "Error": "This ({}) Category does not exist".format( request.data["category"]) })
def get( self, request, slug, format=None, ): product = Product.objects.filter(slug=slug) if not product.exists(): return CustomJSONRenderer().render400() return CustomJSONRenderer().renderData( ProductSerializer(product.first(), context={ 'request': request }, many=False).data)
def to_internal_value(self, data): if 'warehouse_components_list' in data: component_ids = [ component['component_id'] for component in data['warehouse_components_list'] ] data['warehouse_components'] = WarehouseItemComponentSerializer( WarehouseComponent.objects.filter(id__in=component_ids), many=True) if 'product_id' in data: data['product'] = ProductSerializer( get_object_or_404(Product.objects.all(), pk=data['product_id'])) return super().to_internal_value(data)
class CartItemSerializer(serializers.Serializer): product_id = serializers.IntegerField() quantity = serializers.IntegerField() size = serializers.CharField(max_length=20) product = ProductSerializer(read_only=True) total_price = serializers.SerializerMethodField(read_only=True) def get_total_price(self, instance): return instance.get_total_price() def create(self, validated_data): return CartItem( product_id=validated_data.get('product_id'), quantity=validated_data.get('quantity'), size=validated_data.get('size'), )
def test_create_order(self): number_of_product = randrange(1, 10) [self.create_product(self._NAME.example(), self._CONTENT.example(), self._PRICE.example()) for _ in range(number_of_product)] products = Product.objects.all()[:number_of_product] factory = APIRequestFactory() request = factory.get("/") products_list = [ProductSerializer(product, context={'request': request}).data['url'] for product in products] data = { "ref_no": self._NAME.example(), "customer_name": self._NAME.example(), "products": products_list, "discount": self._DISCOUNT.example() } response = self.client.post("/shop/orders/", data) self.assertIs(response.status_code, 201) self.assertIsNotNone(response.data["url"]) self.assertIs(response.data["state"], Order.PENDING) return response.data["url"]
def get(self, request, slug=None, format=None): search = request.GET.get('search', None) if slug: slug = str(slug).replace('/', '') products = self.get_queryset(request, slug) if products is None: return CustomJSONRenderer().render404('product', '') companySlug = request.GET.get('company_slug', None) dataCompany = None if companySlug: company = Company.objects.filter(slug=companySlug) if company.count() > 0: dataCompany = company.first() return CustomJSONRenderer().renderData( OrderedDict([('count', self.page.paginator.count), ('next', self.get_next_link()), ('previous', self.get_previous_link()), ('results', ProductSerializer(products, context={ 'request': request }, many=True).data), ('dataCompany', CompanySerializer(dataCompany, many=False, context={ 'request': request }, pop=['available']).data if dataCompany else None)])) # return CustomJSONRenderer().renderData( # ProductSerializer(products , context={'request': request} , many=True).data) else: print('None slug LabelViews ') PLable = None if search is not None: PLable = ProductLabel.objects.filter(Q(name__contains=search)) return CustomJSONRenderer().renderData( ProductLabelSerializer(PLable, many=True, pop=['available']).data)
def test_order_total_calculation(self): number_of_product = randrange(1, 10) [self.create_product(self._NAME.example(), self._CONTENT.example(), self._PRICE.example()) for _ in range(number_of_product)] products = Product.objects.all()[:number_of_product] factory = APIRequestFactory() request = factory.get("/") products_list = [ProductSerializer(product, context={'request': request}).data['url'] for product in products] discount = self._DISCOUNT.example() data = { "ref_no": self._NAME.example(), "customer_name": self._NAME.example(), "products": products_list, "discount": discount, "total": 0 } total_should_be = sum([p.price for p in products]) - discount response = self.client.post("/shop/orders/", data) self.assertIs(response.status_code, 201) self.assertEqual(Decimal(response.data["total"]), total_should_be) return response.data["url"]
def get(cls, request, user_id, store_id, product_id) -> Response: product = cls.get_object(product_id) serializer = ProductSerializer(product) return Response(serializer.data, status=status.HTTP_200_OK)
class WarehouseItemSerializer(serializers.ModelSerializer): warehouse_components = WarehouseItemComponentSerializer(many=True, read_only=True) product = ProductSerializer(read_only=True) warehouse_components_list = WarehouseItemComponentSerializer( many=True, write_only=True) product_id = serializers.IntegerField(write_only=True) class Meta: model = WarehouseItem fields = [ 'id', 'product', 'warehouse_components', 'warehouse_components_list', 'product_id', ] def to_internal_value(self, data): if 'warehouse_components_list' in data: component_ids = [ component['component_id'] for component in data['warehouse_components_list'] ] data['warehouse_components'] = WarehouseItemComponentSerializer( WarehouseComponent.objects.filter(id__in=component_ids), many=True) if 'product_id' in data: data['product'] = ProductSerializer( get_object_or_404(Product.objects.all(), pk=data['product_id'])) return super().to_internal_value(data) @staticmethod def update_or_create_components(components, instance): if components: current_components = [] for warehouse_component in components: component_id = warehouse_component['component']['id'] WarehouseItemComponent.objects.update_or_create( item=instance, component_id=component_id, defaults={ 'quantity': warehouse_component['quantity'], }) current_components.append(component_id) instance.warehouse_components.exclude( component_id__in=current_components).delete() @transaction.atomic def create(self, validated_data): warehouse_components = validated_data.pop('warehouse_components_list') product = validated_data.pop('product_id') if product is not None: validated_data['product'] = Product.objects.get(id=product) instance = super().create(validated_data) self.update_or_create_components(warehouse_components, instance) return instance @transaction.atomic def update(self, instance, validated_data): warehouse_components = validated_data.pop('warehouse_components_list', None) product = validated_data.pop('product_id', None) if product is not None: validated_data['product'] = Product.objects.get(id=product) instance = super().update(instance, validated_data) self.update_or_create_components(warehouse_components, instance) return instance
def retrieve(self, request, *args, **kwargs): queryset = Product.objects.all() user = get_object_or_404(queryset, pk=kwargs.get('pk')) serializer = ProductSerializer(user) return Response(serializer.data)
def get_product(self, obj): return ProductSerializer(obj.product).data
class OrderProductSerialzier(serializers.ModelSerializer): product = ProductSerializer(many=False) class Meta: model = OrderProduct fields = "__all__"
def get(self, request, pk1, pk2): product1 = self.get_product(request, pk1, pk2) serializer = ProductSerializer(product1) return Response(serializer.data)