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)