def add_product(self, data):
results = {}
user = ''
admin = ''
if 'admin' in data:
admin = data['admin']
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
results['result'] = 'success'
else:
print(serializer.errors)
return
token = data['token']
user = Token.objects.get(key=token).user
if user or 'yes' in admin:
if user.has_perm() or 'yes' in admin:
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
results['result'] = 'success'
else:
results['result'] = 'error'
if 'image' in serializer.errors:
results['error'] = ": nie prawidłowy plik najpewniej nie jest to zdjęcie"
if 'productName' in serializer.errors:
if 'error' in results:
results['error'] = results['error'] + " " + "oraz produkt o takiej nazwie już istnieje"
else:
results['error'] = ": produkt o takiej nazwie już istnieje"
else:
results['error'] = "Nie masz uprawnień bądź zostałeś wylogowany"
else:
results['error'] = "Nie masz uprawnień bądź zostałeś wylogowany"
return results
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 bar(self, request):
bar_code = self.request.query_params.get('bar', '')
if not bar_code:
return HttpResponseBadRequest('No bar code in get parameters')
products = Product.objects.filter(bar_code=bar_code)
if products:
return Response(ProductSerializer(instance=products[0]).data)
else:
url = 'http://goodsmatrix.ru/goods/d/' + bar_code + '.html'
resp = requests.get(url)
soup = BeautifulSoup(resp.text)
if soup.find(id='ctl00_ContentPH_GoodsName'):
name = soup.find(id='ctl00_ContentPH_GoodsName').text
description = soup.find(id='ctl00_ContentPH_Comment').text
composition = soup.find(id='ctl00_ContentPH_Composition').text
image_url = 'http://goodsmatrix.ru/BigImages/' + bar_code + '.jpg'
img = requests.get(image_url)
path = join(settings.MEDIA_ROOT, 'big_images', bar_code + '.jpg')
with open('/tmp/food_debug', 'w') as outp:
outp.write(path)
with open(path, 'wb') as img_file:
img_file.write(img.content)
product = Product(name=name, bar_code=bar_code, description=description, composition=composition)
product.image.name = path
product.save()
return Response(ProductSerializer(instance=product).data)
else:
return HttpResponseBadRequest('No such bar code in database')
def post(self, request):
request.data["company"] = request.user.company.id
serializer = ProductSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
product_id = serializer.data['id']
Storage.objects.create(product_id=product_id, rest=0, last_price=0, market_price=0, total_price=0)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, filter_type, sort_type):
domain = get_current_site(request).domain
token = request.META.get('HTTP_AUTHORIZATION')[6:]
if token != "57bcb0493429453fad027bc6552cc1b28d6df955":
serializer = SearchHistorySerializer(
data={
"user": request.user.id,
"searched": request.data["searched"]
})
if serializer.is_valid():
serializer.save(user_id=request.user.id)
word_list = datamuse_call(request.data["searched"])
product_list = search_product_db(word_list,
request.data["searched"])
filter_type = str(filter_type)
sort_type = str(sort_type)
filter_types = filter_type.split("&")
product_list = filter_func(filter_types, product_list)
product_list = sort_func(sort_type, product_list)
product_list2 = []
for i in range(len(product_list)):
product = ProductSerializer(
Product.objects.get(id=product_list[i]["id"]),
context={
'request': request
}).data
product_list2.append(product)
product_dict = {}
product_dict["product_list"] = product_list2
return Response(product_dict, status=status.HTTP_200_OK)
return Response(serializer._errors,
status=status.HTTP_400_BAD_REQUEST)
else:
word_list = datamuse_call(request.data["searched"])
product_list = search_product_db(word_list,
request.data["searched"])
filter_type = str(filter_type)
sort_type = str(sort_type)
filter_types = filter_type.split("&")
product_list = filter_func(filter_types, product_list)
product_list = sort_func(sort_type, product_list)
for i in range(len(product_list)):
product = ProductSerializer(
Product.objects.get(id=product_list[i]["id"]),
context={
'request': request
}).data
product_list.append(product)
product_dict = {}
product_dict["product_list"] = product_list
return Response(product_dict, status=status.HTTP_200_OK)
def test_retrieve_products_nonadmin(self):
"""Test retrieving a list of products as a non admin user"""
product1 = sample_product(user=self.user)
product2 = sample_product(user=self.user,
description="new description",
status='borrador')
res = self.client_nonadmin.get(PRODUCTS_URL)
serializer1 = ProductSerializer(product1)
serializer2 = ProductSerializer(product2)
self.assertIn(serializer1.data, res.data.get('results'))
self.assertNotIn(serializer2.data, res.data.get('results'))
class CartListSerializer(serializers.Serializer): product = ProductSerializer() quantity = serializers.IntegerField() price = serializers.SerializerMethodField() def get_price(self, obj): return int(obj['product'].price) * obj['quantity']
def test_retrieve_products_assigned_to_orders(self):
product1 = Product.objects.create(user=self.user,
price=2.22,
name='Sandalia')
product2 = Product.objects.create(user=self.user,
price=2.22,
name='Tacon')
order = Order.objects.create(name='My order', user=self.user, number=1)
order.products.add(product1)
res = self.client.get(PRODUCT_URL, {'assigned_only': 1})
serializer1 = ProductSerializer(product1)
serializer2 = ProductSerializer(product2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def get(self, request, format=None):
user = self.request.user
try:
cart = Cart.objects.get(user=user)
cart_items = CartItem.objects.order_by('product').filter(cart=cart)
result = []
if CartItem.objects.filter(cart=cart).exists():
for cart_item in cart_items:
item = {}
item['id'] = cart_item.id
item['count'] = cart_item.count
product = Product.objects.get(id=cart_item.product.id)
product = ProductSerializer(product)
item['product'] = product.data
result.append(item)
return Response({'cart': result}, status=status.HTTP_200_OK)
except:
return Response(
{'error': 'Something went wrong when retrieving cart items'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request):
cust_id = request.GET.get('cust_id')
print(cust_id)
cust_instance = Customer.objects.filter(id=cust_id)
print(cust_instance)
invoiceItems = InvoiceItems.objects.filter(
invoice__customer=cust_instance[0]).select_related(
'invoice', 'product')
invoice_products = []
for item in invoiceItems:
product_data = ProductSerializer(item.product, many=False)
temp = {
"id": item.id,
"original_product": product_data.data,
"added_info": {
'custDescription': item.customerDescription,
'qoutedPrice': item.overiddenPrice,
'requiredQty': item.quatityOffered,
}
}
invoice_products.append(temp)
return Response({
"status": status.HTTP_201_CREATED,
"products": invoice_products
})
def product_auction_create(request):
if request.method == 'POST':
data = JSONParser().parse(request)
name = data['name']
price = data['price']
price_step = data['price_step']
userId = data['userId']
organizationId = data['organizationId']
categoryId = data['categoryId']
exp_time = data['exp_time']
info = data['info']
newProduct = Product(name=name,
detail=info,
price=price,
auction=1,
owner_id=userId,
organization_id=organizationId,
category_id=categoryId,
created_time=datetime.now())
newProduct.save()
serializerNewProduct = ProductSerializer(newProduct)
newAuction = Auction(exp_time=datetime.fromtimestamp(float(exp_time)),
lastest_price=price,
price_step=price_step,
product_id=newProduct.pk)
newAuction.save()
return JsonResponse(serializerNewProduct.data, status=201)
class CheckoutSerializer(serializers.ModelSerializer):
ProductID = ProductSerializer()
class Meta:
model = Checkout
fields = ('ProductID', 'User_ID', 'CreatedDate', 'Quantity',
'promocode', 'incheckout')
class OrderSerializer(serializers.ModelSerializer):
customer = CustomerSerializer(read_only=True)
product = ProductSerializer(read_only=True)
class Meta:
model = Order
fields = ["id", "customer", "product", "quantity", "created_at"]
class ProjectListSerializer(serializers.ModelSerializer):
images = ProjectPictureSerializer(many=True, read_only=True)
category = ProjectCategorySerializerNested(many=True)
community = CommunityProductListSerializer(many=True)
from product.serializers import ProductSerializer
products = ProductSerializer()
class Meta:
model = Project
fields = ('id', 'name', 'target_area', 'theme_description', 'goals',
'specific_goals', 'activities', 'results', 'schedule',
'target_audience', 'project_totals', 'taxes',
'community_tour', 'future_vision', 'category', 'images',
'products', 'community')
read_only_fields = ('id', )
def create(self, validated_data):
categories_data = validated_data.pop('category')
project = Project.objects.create(**validated_data)
for category_data in categories_data:
category = ProjectCategory.objects.create(**category_data)
project.category.add(category)
return project
def products_list(request):
"""
List all code product mapping.
"""
try:
if request.method == 'GET':
product = Product.objects.all()
serializer = ProductSerializer(product, many=True)
if serializer:
return JSONResponse({
"m": "success",
"s": 1,
"d": serializer.data
})
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "No data available."
},
status=200)
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requset Method must be GET"
},
status=200)
except Exception as e:
return JSONResponse({"m": "fail", "s": 0, "d": e}, status=200)
def product_create_attribute(request):
if request.method == 'POST':
data = JSONParser().parse(request)
name = data['name']
price = data['price']
sellerId = data['sellerId']
organizationId = data['organizationId']
categoryId = data['categoryId']
# quantity = sum()
attributes = data['attributes']
info = data['info']
newProduct = Product(name=name,
detail=info,
price=price,
auction=0,
owner_id=sellerId,
organization_id=organizationId,
category_id=categoryId,
created_time=datetime.now())
newProduct.save()
for attribute in attributes['values']:
newAttribute = ProductAttribute(name=attributes['name'],
product_id=newProduct.id,
quantity=attribute['quantity'],
value=attribute['value'])
newAttribute.save()
serializerNewProduct = ProductSerializer(newProduct)
return JsonResponse(serializerNewProduct.data, status=201)
def get(self, request, format=None):
user = self.request.user
try:
wishlist = WishList.objects.get(user=user)
wishlist_items = WishListItem.objects.filter(wishlist=wishlist)
result = []
if WishListItem.objects.filter(wishlist=wishlist).exists():
for wishlist_item in wishlist_items:
item = {}
item['id'] = wishlist_item.id
product = Product.objects.get(id=wishlist_item.product.id)
product = ProductSerializer(product)
item['product'] = product.data
result.append(item)
return Response({'wishlist': result}, status=status.HTTP_200_OK)
except:
return Response(
{
'error':
'Something went wrong when retrieving wishlist items'
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request):
week1_revenue = 0.0
week2_revenue = 0.0
week3_revenue = 0.0
week4_revenue = 0.0
delivered_orders_one = Seller.objects.get(pk=request.user.id).seller_orders.filter(order_status='delivered',date__range=[date.today() - relativedelta(weeks=1), date.today()])
delivered_orders_two = Seller.objects.get(pk=request.user.id).seller_orders.filter(order_status='delivered',date__range=[date.today() - relativedelta(weeks=2),date.today() - relativedelta(weeks=1)])
delivered_orders_three = Seller.objects.get(pk=request.user.id).seller_orders.filter(order_status='delivered',date__range=[date.today() - relativedelta(weeks=3), date.today() - relativedelta(weeks=2)])
delivered_orders_four = Seller.objects.get(pk=request.user.id).seller_orders.filter(order_status='delivered',date__range=[date.today() - relativedelta(weeks=4), date.today() - relativedelta(weeks=3)])
for order in delivered_orders_one:
week1_revenue = week1_revenue+order.sub_total
for order in delivered_orders_two:
week2_revenue = week2_revenue+order.sub_total
for order in delivered_orders_three:
week3_revenue = week3_revenue+order.sub_total
for order in delivered_orders_four:
week4_revenue = week4_revenue + order.sub_total
revenues = {"week1_revenue": week1_revenue}
revenues.update({"week2_revenue": week2_revenue})
revenues.update({"week3_revenue": week3_revenue})
revenues.update({"week4_revenue": week4_revenue})
revenues.update({"total_revenue": week1_revenue + week2_revenue + week3_revenue + week4_revenue})
products = Seller.objects.get(pk=request.user.id).products.all()
serializer=ProductSerializer(products,many=True)
revenues['products']=serializer.data
return Response(revenues)
class CommunitySerializer(serializers.ModelSerializer):
leadership = CommunityLeadershipSerializer()
contacts = CommunityContactsSerializer(many=True)
images = CommunityPictureSerializer(many=True)
schools = CommunitySchoolSerializer(many=True)
biomes = CommunityBiomesSerializer(many=True)
craftworks = CommunityCraftworkSerializer(many=True)
address = AddressSerializer()
products = ProductSerializer(many=True)
class Meta:
model = Community
fields = ('id', 'name', 'geo_lat', 'geo_long', 'distance_from_capital',
'idh_state', 'idh_city', 'energy_type', 'families_number',
'religion', 'traditional_culture', 'craftworks', 'traditional_events',
'sanctuaries', 'hospitals_number', 'ready_care_number', 'psf_number',
'address', 'leadership', 'products', 'contacts', 'images', 'schools',
'biomes')
read_only_fields = ('id',)
def create(self, validated_data):
address_data = validated_data.pop('address')
address = Address.objects.create(**address_data)
community = Community(**validated_data)
community.address = address
community.save()
leaderships_data = validated_data.pop('leadership')
for leadership_data in leaderships_data:
CommunityLeadership.objects.create(community=community, **leadership_data)
contacts_data = validated_data.pop('contacts')
for contact_data in contacts_data:
CommunityContacts.objects.create(community=community, **contact_data)
images_data = validated_data.pop('images')
for image_data in images_data:
CommunityPicture.objects.create(community=community, **image_data)
schools_data = validated_data.pop('schools')
for school_data in schools_data:
CommunitySchools.objects.create(community=community, **school_data)
biomes_data = validated_data.pop('biomes')
for biome_data in biomes_data:
CommunityBiomes.objects.create(community=community, **biome_data)
craftworks_data = validated_data.pop('craftwork')
for craftwork_data in craftworks_data:
CommunityCraftwork.objects.create(community=community, **craftwork_data)
return community
def product_list_posted(request):
products = Product.objects.filter(published=True)
# find all products with published = True:
if request.method == 'GET':
products_serializer = ProductSerializer(products, many=True)
return JsonResponse(products_serializer.data, safe=False)
def test_get_valid_single_product(self):
response = client.get(
reverse('get_delete_update_product', kwargs={'pk': self.apple.pk}))
product = Product.objects.get(pk=self.apple.pk)
serializer = ProductSerializer(product)
self.assertEqual(response.data, serializer.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_single_product(self):
updated_payload = {'name': 'Updated Product Heehe', 'category': [1]}
product = Product.objects.get(id=1)
response = self.client.put(f'/api/v1/products/{product.slug}/',
updated_payload,
format='json',
**self.user_jwt)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
response = self.client.put(f'/api/v1/products/{product.slug}/',
updated_payload,
format='json',
**self.admin_jwt)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data,
ProductSerializer(
Product.objects.get(slug='updated-product-heehe')).data)
response = self.client.put(f'/api/v1/products/{product.slug}/',
updated_payload,
format='json',
**self.admin_jwt)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def product_create(request):
if request.method == 'POST':
data = JSONParser().parse(request)
name = data['name']
price = data['price']
userId = data['userId']
organizationId = data['organizationId']
categoryId = data['categoryId']
quantity = data['quantity']
info = data['info']
newProduct = Product(name=name,
detail=info,
price=price,
quantity=quantity,
auction=0,
owner_id=userId,
organization_id=organizationId,
category_id=categoryId,
created_time=datetime.now())
newProduct.save()
serializerNewProduct = ProductSerializer(newProduct)
return JsonResponse(serializerNewProduct.data, status=201)
def put(self, request, slug):
"""
Update Product
Update product that the slug mentioned, returned the updated product if succesful.<br>
Return 404 if no product with that slug is found.
"""
product = self.get_object(slug)
try:
serializer = ProductSerializer(product, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
except ValidationError:
return Response(serializer.errors, status=status.HTTP_409_CONFLICT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk):
products = Product.objects.filter(Q(category__id__icontains=pk))
serializer = ProductSerializer(products, many=True)
if not products:
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(serializer.data, status.HTTP_200_OK)
class InvoiceItemsSerializer(serializers.ModelSerializer):
product = ProductSerializer()
invoice = InvoiceSerlializer()
class Meta:
model = InvoiceItems
fields = ('id', 'overiddenPrice', 'quatityOffered',
'customerDescription', 'product', 'invoice')
def get(self, request, id):
product = self.get_product(id)
serializer = ProductSerializer(product)
try:
return Response(serializer.data)
except:
return HttpResponse("product id " + str(id) + " not found",
status=HTTP_404_NOT_FOUND)
def product_create(request):
if request.method == 'POST':
data = {'name': request.DATA.get('name'),
'brand': request.DATA.get('brand'),
'measure': request.DATA.get('measure'),
'unit_size': request.DATA.get('unit_size'),
'unit_price': request.DATA.get('unit_price'),
'category_id': request.DATA.get('category_id'),
'ingredient_id': request.DATA.get('ingredient_id'),
}
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 test_product_get(db, client):
"""Test"""
product = baker.make(Product)
url = reverse("product:get", args=(product.pk, ))
response = client.get(url)
data = response.json()
assert response.status_code == 200
assert ProductSerializer(product).data == data
def getProductDetail(request, pk):
# find product by pk (id)
try:
product = BaseProduct.objects.get(pk=pk)
except BaseProduct.DoesNotExist:
return JsonResponse({'message': 'The product does not exist'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
product_serializer = ProductSerializer(product)
return JsonResponse(product_serializer.data)
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)
elif request.method == 'DELETE':
product.delete()
return JsonResponse({'message': 'Product was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def product_list(request):
# GET list of Product, POST a new Product, DELETE all Product
if request.method == 'GET':
product = Product.objects.all()
name = request.GET.get('name', None)
if name is not None:
product = product.filter(name__icontains=name)
product_serializer = ProductSerializer(product, many=True)
return JsonResponse(product_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
# product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(data=request.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)
elif request.method == 'DELETE':
count = Product.objects.all().delete()
return JsonResponse(
{
'message':
'{} Product was/were deleted successfully!'.format(count[0])
},
status=status.HTTP_204_NO_CONTENT)