def product_detail(request, id, format=None):
"""
Retrieve, update or delete a product instance.
"""
try:
product = Product.objects.get(id=id)
except Product.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ProductSerializer(product)
return Response(serializer.data)
elif request.method == 'PUT':
if 'ordered' in request.DATA:
del request.DATA['ordered']
serializer = ProductSerializer(product, data=request.DATA, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
if product.ordered:
return Response('Cannot delete ordered product')
product.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def product_detail(request, pk):
"""
Gets a single product
:param request:
:param pk:
returns:
"""
try:
product = Product.objects.get(pk=pk)
except Product.DoesNotExist:
return Response(data={"error": "Product does not exist"}, status=status.HTTP_404_NOT_FOUND)
if request.method == "GET":
serializer = ProductSerializer(product)
return Response(data={"product": serializer.data}, status=status.HTTP_200_OK)
elif request.method == "PUT":
serializer = ProductSerializer(instance=product, data=request.data)
if not serializer.is_valid():
return Response(data={"errors": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(data={"product": serializer.data}, status=status.HTTP_201_CREATED)
elif request.method == "DELETE":
serializer = ProductSerializer(instance=product, data={"is_active": False})
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data={"message": "Product deleted successfully"}, status=status.HTTP_204_NO_CONTENT)
def product_rud(request, id=None):
"""
Retrieve, update or delete a product
"""
try:
product = Product.objects.get(pk=id)
except Product.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
if product:
serializer = ProductSerializer(product)
return Response(serializer.data)
else:
#id = None
product1 = Product.objects.all(id=None)
serializer = ProductSerializer(product1, many=True)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ProductSerializer(product, data=request.data)
if serializer.is_valid():
serializer.save()
print('&&&&&&&&&&&', serializer.data)
return Response(serializer.data)
return Response(status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
product.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, id, format=None):
product = self.get_object(id)
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 product_detail(request, pk):
# find products by pk (id)
try:
tutorial = Product.objects.get(pk=pk)
except Product.DoesNotExist:
return JsonResponse({'message': 'The product does not exist'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
tutorial_serializer = ProductSerializer(tutorial)
return JsonResponse(tutorial_serializer.data)
elif request.method == 'PUT':
tutorial_data = JSONParser().parse(request)
tutorial_serializer = ProductSerializer(tutorial, data=tutorial_data)
if tutorial_serializer.is_valid():
tutorial_serializer.save()
return JsonResponse(tutorial_serializer.data)
return JsonResponse(tutorial_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
tutorial.delete()
return JsonResponse({'message': 'Product was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def create(self, request):
serializer = ProductSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
publish('product_created', serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def product_list(request):
# GET list of products, POST a new products, DELETE all products
if request.method == 'GET':
products = Product.objects.all()
title = request.GET.get('title', None)
if title is not None:
products = products.filter(title__icontains=title)
tutorials_serializer = ProductSerializer(products, many=True)
return JsonResponse(tutorials_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
tutorial_data = JSONParser().parse(request)
tutorial_serializer = ProductSerializer(data=tutorial_data)
if tutorial_serializer.is_valid():
tutorial_serializer.save()
return JsonResponse(tutorial_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(tutorial_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Product.objects.all().delete()
return JsonResponse(
{
'message':
'{} products were deleted successfully!'.format(count[0])
},
status=status.HTTP_204_NO_CONTENT)
def update(self, request, pk=None): # /api/products/<str:id>
product = Product.objects.get(id=pk)
serializer = ProductSerializer(instance=product, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
publish(event_updated, serializer.data) # publishing to RabbitMQ
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def product_detail(request, pk):
try:
product = Product.objects.get(pk=pk)
# find a single product with an id
if request.method == 'GET':
product_serializer = ProductSerializer(product)
return JsonResponse(product_serializer.data)
# update a product by the id in the request
elif request.method == 'PUT':
product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(product, data=product_data)
if product_serializer.is_valid():
product_serializer.save()
return JsonResponse(product_serializer.data)
return JsonResponse(product_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# delete a product with the specified id
elif request.method == 'DELETE':
product.delete()
return JsonResponse(
{'message': 'Product was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
except Product.DoesNotExist:
return JsonResponse({'message': 'The product does not exist'},
status=status.HTTP_404_NOT_FOUND)
def update(self, request, pk=None):
product = Product.objects.get(id=pk)
serializer = ProductSerializer(instance=product, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
publish('product_updated', serializer.data)
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def post(self, request, format=None):
product_serializer = ProductSerializer(data=request.data['data'])
if product_serializer.is_valid():
product_serializer.save()
return Response(product_serializer.data,
status=status.HTTP_201_CREATED)
return Response(product_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def add_product_list(request):
if request.method == 'POST':
product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(data=product_data)
if product_serializer.is_valid():
product_serializer.save()
return JsonResponse(product_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(product_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, **kwargs):
data = request.data
serializer = ProductSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_deserialize_properties(transactional_db):
from products.models import Product
# create
data = {'summary': u'Orange',
'deposit_amount': 10.00,
'currency': u'EUR',
'description': u'',
'address': _location('address-detail', pk=1),
'category': _location('category-detail', pk=1),
'owner': _location('patron-detail', pk=1),
'eloue_color': u'cyan',
'eloue_size': 25}
ps = ProductSerializer(data=data)
assert not ps.errors
ps.save()
p = Product.objects.get(pk=ps.object.pk)
assert p.properties.count() == 3
assert p.properties.filter(property_type__attr_name='color', value_str='cyan').exists()
assert p.properties.filter(property_type__attr_name='size', value_str='25').exists()
assert p.properties.filter(property_type__attr_name='default_value', value_str='5').exists()
# update
data = {'summary': u'Banana',
'deposit_amount': 40.00,
'currency': u'EUR',
'description': u'',
'address': _location('address-detail', pk=1),
'category': _location('category-detail', pk=1),
'owner': _location('patron-detail', pk=1),
'eloue_color': u'yellow',
'eloue_size': 1}
ps = ProductSerializer(Product.objects.get(pk=1), data=data)
assert not ps.errors
ps.save(force_update=True)
p = Product.objects.get(pk=1)
assert p.properties.count() == 3
assert p.properties.filter(property_type__attr_name='color', value_str='yellow').exists()
assert p.properties.filter(property_type__attr_name='size', value_str='1').exists()
assert p.properties.filter(property_type__attr_name='default_value', value_str='5').exists()
assert PropertyValue.objects.count() == 6
assert Property.objects.count() == 4
assert Product.objects.count() == 2
def partial_update(self, request, pk=None, **kwargs):
product = get_object_or_404(self.queryset, pk=pk)
serializer = ProductSerializer(instance=product,
data=request.data,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(status=status.HTTP_200_OK)
def create(self, request):
"""Create new product"""
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
if request.META['SERVER_NAME'] == "testserver":
serializer.save_to_memory(serializer.data)
else:
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def product_list(request):
if request.method == "GET":
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
elif request.method == "POST":
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def add_product(data):
"""
Utility function to add product
:param data: JSON object in the format of products model to add in product.
:return response status 201 and serialized data, if data passed is valid,
otherwise return error with status 400.
"""
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, sku=None):
"""Update whole product"""
queryset = Product.objects.all()
product = get_object_or_404(queryset, sku=sku)
serializer = ProductSerializer(product, data=request.data)
if serializer.is_valid():
if request.META['SERVER_NAME'] == "testserver":
serializer.update_to_memory(product, serializer.validated_data)
else:
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def mutate(cls, root, info, product_id, **kwargs):
product = Product.objects.get(id=product_id)
serializer = ProductSerializer(instance=product,
data=kwargs,
partial=True)
if serializer.is_valid():
serializer.save()
msg = "success"
else:
product = None
msg = serializer.errors
return cls(product=product, message=msg, status=204)
def create(self, request):
today = datetime.date.today()
todays_records = Product.objects.filter(created__gt=today)[:10]
if todays_records.count() > 10:
raise APIException("today limit reached")
data = request.data.copy()
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors)
def product_list(request):
if request.method == 'GET':
productList = Product.objects.all()
serializer = ProductSerializer(productList, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def product_list(request):
"""
List all products, or create a new product.
"""
if request.method == 'GET':
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def handle(self, *args, **options):
json_products = json.loads(urlopen(DATA_SOURCE).read())
for product_json in json_products['products']:
product_json['price'] = product_json['price'].replace('.', '').replace(',', '.')
product_json['price_old'] = product_json['price_old'].replace('.', '').replace(',', '.')
serializer = ProductSerializer(data=product_json)
if serializer.is_valid():
serializer.save()
else:
product = Product.objects.get(pk=int(product_json['id']))
serializer = ProductSerializer(product, data=product_json)
if serializer.is_valid():
serializer.save()
self.stdout.write(self.style.SUCCESS('Successfully populated database.'))
def create(self, request, *args, **kwargs):
product_data = request.data
product_amount_data = {'amount': product_data.get('amount', 1)}
product_serializer = ProductSerializer(data=product_data)
product_serializer.is_valid(raise_exception=True)
product_amount_serializer = ProductAmountSerializer(
data=product_amount_data)
product_amount_serializer.is_valid(raise_exception=True)
product_serializer.save()
product_amount_serializer.save(product=product_serializer.instance)
headers = self.get_success_headers(product_serializer.data)
return Response(product_serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def mutate(cls, root, info, **kwargs):
serializer = ProductSerializer(data=kwargs)
if serializer.is_valid():
product = serializer.save()
msg = "success"
else:
msg = serializer.errors
product = None
return cls(product=product, message=msg, status=201)
def product_list(request, format=None):
"""
List all products, or create a new product.
"""
if request.method == 'GET':
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
elif request.method == 'POST':
if 'id' in request.DATA:
del request.DATA['id']
if 'ordered' in request.DATA:
del request.DATA['ordered']
serializer = ProductSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, *args, **kwargs):
try:
print(request.body)
# Get a product by primary key to be updated
product = Product.objects.get(pk=pk)
except Product.DoesNotExist:
return HttpResponse(status=404)
data = JSONParser().parse(request)
user = User.objects.get(username=request.user)
data['seller'] = user
data['id'] = pk
# Check if the logged in user created the original product
if product.seller_id != user.pk:
return HttpResponse(status=401)
serializer = ProductSerializer(product, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
def product_list(request):
# get list of products
if request.method == 'GET':
products = Product.objects.all()
title = request.GET.get('title', None)
if title is not None:
products = products.filter(title__icontains=title)
products_serializer = ProductSerializer(products, many=True)
return JsonResponse(products_serializer.data, safe=False)
# 'safe=False' for objects serialization
# insert a product
elif request.method == 'POST':
product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(data=product_data)
if product_serializer.is_valid():
product_serializer.save()
return JsonResponse(product_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(product_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
if int(pk) != int(request.data['id']):
return Response(
"Product ID %s doesn't match to edit product's %s" % (
str(pk),
str(request.data['id'])
),
status=status.HTTP_400_BAD_REQUEST
)
try:
product = Product.objects.get(pk=int(request.data['id']))
except Product.DoesNotExist:
serializer = ProductSerializer(data=request.data)
code = status.HTTP_201_CREATED
else:
serializer = ProductSerializer(product, data=request.data)
code = status.HTTP_200_OK
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=code)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
