def add_to_cart(request, product_id, quantity):
# добавляем товар в корзину
product = Product.objects.get(id=product_id)
cart = Cart(request)
cart.add(product, product.price, quantity)
messages.add_message(request, messages.INFO, "Добавлено")
return HttpResponseRedirect(redirect_to='/catalog/{}'.format(product_id))
def post(self, request, *args, **kwargs):
cart = Cart(request)
quantity = 1
product_id = request.POST.get('product_id')
product = Product.objects.get(pk=product_id)
cart.add(product, quantity)
return redirect(request.META.get('HTTP_REFERER'))
def post(self, *args, **kwargs):
slab_list = self.request.POST.getlist('select')
product_id = self.request.POST.get('product')
if slab_list:
cart = Cart(self.request)
cart.add(product_id, slab_id_list=slab_list)
return JsonResponse({'state': 'ok'})
def order_button_api(request, order_id):
if request.method == 'GET':
text = """<h1>Your order id is </h1>""" + order_id
return HttpResponse(text)
if request.method == 'POST':
cart = Cart(request)
cart.removeall()
order = Order.get_object_or_404(Order, order_id=order_id)
orderitems = get_list_or_404(OrderItem, order_id=order.id)
for orderitem in orderitems:
cart.add(orderitem.product, orderitem.quantity)
cart.save()
neworder = Order()
neworder.first_name = order.first_name
neworder.last_name = order.last_name
neworder.email = order.email
neworder.address = order.address
neworder.postal_code = order.postal_code
neworder.city = order.city
neworder.save()
for item in cart:
OrderItem.objects.create(order=neworder,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
return HttpResponse("Order placed")
return HttpResponse(content_type="application/json", status_code=200)
def addMultiple_ToCart(request):
# queryset = WellGeoinfo.objects.all()
# f = WellsFilter(request.GET, queryset=queryset)
if request.method == "POST":
pks = request.POST.getlist("select_chkbox")
print("iiiiiiiiiiiiiiiiii", pks)
# cart_items = request.session['cart']
cart2 = Cart(request)
for i in pks:
cart2.add(i)
# request.session['cart'] =cart2
# queryset = WellGeoinfo.objects.filter(pk__in=pks)
# f = WellsFilter(request.GET, queryset=queryset)
# print('pks',pks)
# print(request.session)
# # do something with selected_objects
else:
pass
# print('Else No pks found')
# # return render(request, 'wells/home.html')
# table = WellGeoinfoTable(f.qs)
# RequestConfig(request, paginate={'per_page': 35}).configure(table)
# # return render(request, 'wells/wellstable_concession_filter.html', {'conc_id':conc_id,'table': table,'filter': f})
return redirect('selectedWellscart')
def add_to_cart(request):
product_id = request.POST.get('id')
quantity = request.POST.get('quantity')
print(product_id, quantity)
product = Product.objects.get(
id=product_id
) #使用ORM执行SELECT * FROM shop_products where id = product_id 查询商品
cart = Cart(request)
incart = Item.objects.filter(
cart=cart.cart, object_id=product_id
) #使用ORM执行SELECT * FROM cart_item where object_id = product_id 查询购物车中商品
print(quantity, product.stock)
if incart.exists(): #看购物车中是否有此商品
if incart[0].quantity + int(
quantity) <= product.stock: #若有，比较购物车内此商品数量加新增数量与库存
cart.add(product, product.price, quantity)
return redirect('/cart')
else:
message = "库存不足，无法加入购物车"
return render(request, 'showProduct.html', locals())
else:
if int(quantity) <= product.stock: #若无，则比较新增数量与库存
cart.add(product, product.price, quantity)
return redirect('/cart')
else:
message = "库存不足，无法加入购物车"
return render(request, 'showProduct.html', locals())
def product(request, category_slug, product_slug):
cart = Cart(request)
product = get_object_or_404(Product,
category__slug=category_slug,
slug=product_slug)
if request.method == 'POST':
form = AddtoCartForm(request.POST)
if form.is_valid():
quantity = form.cleaned_data['quantity']
cart.add(product_id=product.id,
quantity=quantity,
update_quantity=False)
messages.success(request, 'The product was added to the cart')
return redirect('product',
category_slug=category_slug,
product_slug=product_slug)
else:
form = AddtoCartForm(request.POST)
similar_product = list(
product.category.products.exclude(id=product.id))
if len(similar_product) >= 4:
similar_product = random.sample(similar_product, 4)
return render(request, 'product/product.html', {
'product': product,
'similar_product': similar_product,
'form': form
})
def item_increment(request, id):
cart = Cart(request)
product = Product.objects.get(id=id)
cart.add(product=product)
messages.add_message(request, messages.SUCCESS, 'quantity changed')
return redirect(
request.META.get('HTTP_REFERER', 'redirect_if_referer_not_found'))
def add_to_cart(request, product_slug):
quantity = 1
product = Products.objects.get(slug=product_slug)
cart = Cart(request)
cart.add(product, product.price, quantity)
return render_to_response('cart.html', dict(cart=Cart(request)))
def product_detail(request, category_slug, id, slug):
category_list = Category.objects.all()
category = Category.objects.get(slug=category_slug)
product = get_object_or_404(Product, id=id, slug=slug)
start_price = product.price * 70 / 100
end_price = product.price * 130 / 100
cart_product_form = CartAddProductForm(
request.POST if request.method == 'POST' else None, product=product)
similar_products = Product.objects.filter(
category=category,
price__range=(start_price, end_price)).exclude(id=id)[:4]
title = product.name
button = '<<< Back to %s' % category.name
if request.method == 'POST':
if cart_product_form.is_valid():
cart = Cart(request)
cart.add(product=product,
quantity=cart_product_form.cleaned_data['quantity'],
update_quantity=False)
return redirect('cart:cart_detail')
return render(
request, 'shop/product_detail.html', {
'product': product,
'title': title,
'similar_products': similar_products,
'category_list': category_list,
'cart_product_form': cart_product_form,
'button': button,
})
def cart_add(request, id):
cart = Cart(request)
product = Product.objects.get(id=id)
cart.add(product=product)
messages.add_message(request, messages.SUCCESS,
'product added to cart successfully')
return redirect("home")
def add_to_cart(req, product_id, quantity=1):
try:
props = json.loads(req.GET['props'])
except:
props = []
if not props:
props = []
product = Product.objects.get(id=product_id)
order_item = OrderItem()
order_item.product = product
order_item.save()
for prop in props:
pps = list(
ProductProp.objects.filter(title=prop['name'],
product_id=product.id,
value=prop['value']))
if len(pps):
pp = pps[0]
order_item.props.add(pp)
cart = Cart(req)
cart.add(order_item, product.price, quantity)
return JsonResponse({'success': True, 'count': cart.count()})
def cart_add(request, id):
cart = Cart(request)
product = models.Cartilla.objects.get(id=id)
cart.add(product=product)
# return HttpResponseRedirect(request.META.get('HTTP_REFERER', 'cartilla/'))
# return redirect("eess:cart_detail")
return redirect_to(request, 'eess:cart_detail')
def test_get_total_price_in_cart(self):
request = self.request
cart = Cart(request)
for prod_id in range(1, 5):
product = Product.objects.get(id=prod_id)
cart.add(product)
self.assertEqual(cart.get_total_price(), 1000.00)
def create(self, request):
id = request.data.get('id')
cart = Cart(self.request)
if not Recipe.objects.filter(pk=id).exists() or cart.in_cart(id):
return Response(status=status.HTTP_400_BAD_REQUEST, data=UNSUCCESS)
cart.add(id)
return Response(status=status.HTTP_201_CREATED, data=SUCCESS)
def cart_add(request, item_id=None):
cart = Cart(request)
product = ShopProduct.objects.get(id=item_id)
form = forms.CartForm(data=request.POST)
if form.is_valid():
cart.add(product, product.price, form.cleaned_data['quantity'])
return redirect('cart_detail')
def add_item_to_cart(request, key):
"""
:param request:
:param key:
:return request.post -> request, new_sale.html, context{form, items ,cart, quantity}:
:return request.get -> request, new_sale.html, context{form, items, cart, quantity}:
"""
item = Item.objects.get(id=key)
cart = Cart(request)
quantityform = QuantityForm(request.POST or None)
if quantityform.is_valid():
# Valid form
unit = quantityform.cleaned_data.get('unit')
if unit <= item.get_remaining_quantity():
# Put unit not to inventory level
cart.update(quantity=unit, product=item, unit_price=item.price)
else:
cart.update(quantity=item.get_remaining_quantity(),
product=item,
unit_price=item.price)
messages.error(
request,
'{} remaining is {}'.format(item.name,
item.get_remaining_quantity()))
return redirect('/sale/new/')
if item.get_remaining_quantity() == 0:
messages.error(request, 'There no {} remaining.'.format(item.name))
else:
cart.add(item, item.price, quantity=1)
return redirect('/sale/new/')
def add_sandwich(request, base):
cart = Cart(request.session)
sand_base = get_object_or_404(Base, pk=base)
form = SandwichForm(request.POST, initial={'base': base})
form2 = QuantityForm(request.POST)
if form.is_valid() and form2.is_valid():
bread = form.cleaned_data['bread']
toppings = form.cleaned_data['toppings']
condiments = form.cleaned_data['condiments']
cheeses = form.cleaned_data['cheeses']
side= form.cleaned_data['side']
quantity = form2.cleaned_data['quantity']
sandwich = Sandwich()
sandwich.base= sand_base
sandwich.bread= bread
sandwich.save()
sandwich.side= side
sandwich.toppings= toppings
sandwich.condiments= condiments
sandwich.cheeses= cheeses
sandwich.save()
product = sandwich
cart.add(product, price=sandwich.price, quantity=quantity)
return HttpResponseRedirect(reverse('cart:show_cart'))
return render(request, 'sandwich_builder/sandwich_constructor.html',
{'base': sand_base, 'form':form})
def cart_add(request):
id = request.GET['add_cart']
quantity = request.GET['count']
cart = Cart(request)
product = Product.objects.get(id=int(id))
cart.add(product=product, quantity=int(quantity))
return redirect("cart_detail")
def add_to_cart(request, product_id, user_id):
product = Product.objects.get(id=product_id)
user_id = user_id
quantity = request.POST['quantity']
cart = Cart(request, user_id)
cart.add(product, product.price, quantity)
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
class TestShow(TestCase):
def setUp(self):
rf = RequestFactory()
request = rf.get(reverse('cart-show'))
add_session_to_request(request)
self.cart = Cart(request)
product = ProductFactory()
self.cart.add(product, product.price, 1)
self.client = Client()
engine = import_module(settings.SESSION_ENGINE)
store = engine.SessionStore()
store.save()
self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
def test_get(self):
# store cart id in session
session = self.client.session
session['CART-ID'] = self.cart.cart.pk
session.save()
resp = self.client.get(reverse('cart-show'))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'check/cart.html')
def test_post(self):
data = {}
for item in self.cart:
data['%s-quantity' % item.product.pk] = 2
# store cart id in session
session = self.client.session
session['CART-ID'] = self.cart.cart.pk
session.save()
resp = self.client.post(reverse('cart-show'), data=data)
self.assertRedirects(resp, reverse('cart-check-in'), status_code=302, target_status_code=200)
def test_payment_payment_rejected(self, mock_Paystack):
order = mixer.blend(Order)
req = RequestFactory().post(
reverse_lazy("orders:download", args=[order.id]))
middleware = SessionMiddleware()
middleware.process_request(req)
req.session.save()
# create a book instance and add it to cart
book = create_book_instance()
ct = Cart(req)
ct.add(book)
mock_Paystack(
secret_key=settings.PAYSTACK_SECRET_KEY
).transaction.verify = MagicMock(
return_value={
'data': {
'status': 'failed',
'amount': ct.get_total_price() * 100,
'gateway_response': "payment was not successful"
}
})
resp = confirm_payment(req, order.id)
updated_order = Order.objects.first()
self.assertFalse(updated_order.paid)
def order_reorder(request, order_id):
#cart = Cart(request)
#if request.method == 'POST':
# cart.removeall()
# order = get_object_or_404(Order, order_id=order_id)
# orderitems = get_list_or_404(OrderItem, order_id=order.id)
# for orderitem in orderitems:
# cart.add(orderitem.product, orderitem.quantity)
# cart.save()
# order_create(request)
# return render(request, 'orders/order/created.html', {'order': order})
#return redirect('cart:cart_detail')
cart = Cart(request)
cart.removeall()
order = get_object_or_404(Order, order_id=order_id)
orderitems = get_list_or_404(OrderItem, order_id=order.id)
for orderitem in orderitems:
cart.add(orderitem.product, orderitem.quantity)
cart.save()
neworder = Order()
neworder.first_name = order.first_name
neworder.last_name = order.last_name
neworder.email = order.email
neworder.address = order.address
neworder.postal_code = order.postal_code
neworder.city = order.city
neworder.save()
for item in cart:
OrderItem.objects.create(order=neworder,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
return render(request, 'orders/order/created.html', {'order': neworder})
def product_detail(request, id, slug):
cart = Cart(request)
product = get_object_or_404(Product, id=id, slug=slug, available=True)
if request.method == "POST":
cart_product_form = CartAddProductForm(request.POST)
if cart_product_form.is_valid():
cd = cart_product_form.cleaned_data
cart.add(product=product,
quantity=cd['quantity'],
update_quantity=cd['update'])
return redirect('cart:cart_detail')
else:
#product = get_object_or_404(Product, id=id, slug=slug, available=True)
cart_product_form = CartAddProductForm()
categories = Category.objects.all()
return render(
request, 'detail.html', {
'product': product,
'cart_product_form': cart_product_form,
'categories': categories
})
def cart_add(request, id):
cart = Cart(request)
# Getting The Values
if request.method == 'POST':
global product, color, size, quantity
product = Product.objects.get(id=id)
color = request.POST['color']
size = request.POST['size']
quantity = request.POST['quantity']
# Adding the products in cart
cart.add(product=product, color=color, size=size, quantity=int(quantity))
# Sending Action and Notification To The User
action.send(
request.user,
verb="Product Has Been Added",
description=
f"The User {request.user} has added the product {product} in his cart of the color {color} and size of {size} and quantity of {quantity}",
action_object=product)
notify.send(
request.user,
verb="Product Has Been Added In Your Cart",
recipient=request.user,
level="success",
action_object=product,
description=
f"The User {request.user} has added the product {product} in his cart")
return redirect("Home")
def item_increment(request, id):
print(id)
if 'sid' not in request.session:
n = random.randint(1000000000,9999999999)
request.session['sid'] = n
print(request.session['sid'])
else:
print(request.session['sid'])
pass
sid = request.session['sid']
cart = Cart(request)
product1 = product.objects.get(id=id)
cart.add(product=product1)
with connection.cursor() as cursor:
cursor.execute('SELECT * FROM app_product WHERE id = %s',[id])
results = namedtuplefetchall(cursor)
print(results[0].heading)
hdg = results[0].heading
print(results[0].quantity)
# qty = results[0].quantity
# print(qty)
if cartt.objects.filter(heading=hdg, sessionid=sid).exists():
n = cartt.objects.filter(heading=hdg, sessionid=sid).values_list('quantity', flat=True)
m = dict(Mobile=list(n))
m1 = m['Mobile']
c = str(m1)[1:-1]
print(c)
qty = int(c)
qty1 = int(qty) + 1
print(qty1)
cartt.objects.filter(heading=hdg, sessionid=sid).update(quantity=qty1)
print('item increment')
return redirect("cart_detail")
class CartTest(TestCase):
def setUp(self):
self.category = Category(name="smartphones", slug="smart")
self.category.save()
self.test_product1 = Product(category=self.category,
name="Xperia",
stock=12,
price=1000)
self.test_product2 = Product(category=self.category,
name="Iphone",
stock=12,
price=50000)
self.test_product1.save()
self.test_product2.save()
self.cart = Cart(MockedRequest())
def test_add(self):
self.cart.add(self.test_product1, 1, update_quantity=True)
self.assertEquals(len(self.cart.cart), 1)
self.assertTrue(str(self.test_product1.id) in self.cart.cart)
product = self.cart.cart[str(self.test_product1.id)]
self.assertEquals(product["quantity"], 1)
self.assertEquals(product["price"], str(self.test_product1.price))
def test_update(self):
self.cart.add(self.test_product1, 1, update_quantity=True)
self.assertTrue(str(self.test_product1.id) in self.cart.cart)
self.cart.add(self.test_product1, 1)
product = self.cart.cart[str(self.test_product1.id)]
self.assertEquals(product["quantity"], 2)
def test_save(self):
self.cart.save()
self.assertTrue(self.cart.session.modified)
self.assertTrue(settings.CART_SESSION_ID in self.cart.session)
def test_remove(self):
self.cart.add(self.test_product1, 1, update_quantity=True)
self.cart.add(self.test_product2, 1, update_quantity=True)
self.cart.remove(self.test_product1)
self.assertEquals(len(self.cart.cart), 1)
self.assertTrue(str(self.test_product2.id) in self.cart.cart)
product = self.cart.cart[str(self.test_product2.id)]
self.assertEquals(product["quantity"], 1)
self.assertEquals(product["price"], str(self.test_product2.price))
# работа итератора __iter__ я так понимаю провериться в тесте def test_get_total_price(self):
def test_get_total_price(self):
self.cart.add(self.test_product1, 1, update_quantity=True)
self.cart.add(self.test_product2, 1, update_quantity=True)
test_sum_price = self.test_product1.price + self.test_product2.price
total = sum(
Decimal(item['price']) * item['quantity']
for item in self.cart.cart.values())
self.assertEquals(total, test_sum_price)
def test_clear(self):
del self.cart.session
self.assertTrue(settings.CART_SESSION_ID not in self.cart)
def add_to_cart(request):
product_id = request.POST.get('product_id')[0]
product = Product.objects.get(pk=product_id)
cart = Cart(request)
quantity = 1
cart.add(product, product.price, quantity)
return HttpResponse(cart.summary())
def add_project_to_cart(self, request, *args, **kwargs):
project = ProjectPage.objects.get(id=request.POST.get('project_id'))
cart = Cart(request)
cart.add(project, request.POST.get('amount'), 1)
request.session['funder_name']=request.POST.get('name')
request.session['funder_organisation']=request.POST.get('organisation')
return redirect('/order/checkout')
def post(self, request, *args, **kwargs):
"""Добавить товар в корзину на странице - карточка товара - Ajax"""
print(request.POST)
obj = ProductItem.objects.get(id=request.POST['product_id'])
response_data = {
'product_id': obj.id,
'name': obj.name,
'articul': obj.articul,
'quantity': int(request.POST.get('quantity', 0)),
'price': float(obj.price)
}
cart = Cart(request)
form = CartAddProductForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
cart.add(product=obj,
quantity=cd['quantity'],
is_update_qty=cd['is_update'])
return HttpResponse(json.dumps(response_data),
content_type="application/json")
def add_to_cart(request, isbn):
print('method get')
print(isbn)
product = BookModel.objects.get(isbn=isbn)
cart = Cart(request)
cart.add(product, product.prices, product.quantity)
return redirect("/site")
def myajaxtestviewtext(request):
print(
"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
print(request.POST['text'])
print(
"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
s = str(request.POST['text'])
sb.temp = 0
if (sb.temp > 0 or s == "checkout"):
# print("Checking out")
sb.temp = sb.temp + 1
if (sb.temp == 1):
resp = sb.handle("show list")
resp, sb.other = resp
sb.address = s
flag = 0
for product, quantity in sb.other:
print("YO")
p1 = Product.objects.filter(slug=product)[0]
p = Product.objects.get(productid=p1.productid)
cart = Cart(request)
qty = p.quantity
if quantity > qty:
resp = "Number of Items exceeded the stock..\nPlease Clear the list and try again."
return HttpResponse(resp)
p.quantity = qty - quantity
p.save()
cart.add(product=p, quantity=quantity)
# u = User.objects.get(username=request.user.username)
# o = Order(item=product,quantity=quantity,price=p.price,total=(int(quantity)*int(p.price)),name=request.user.username,phone=sb.phone,email=u.email,address=sb.address,user_id=u.id)
# o.save()
resp = "Adding... \nCheck CART"
sb.handle("clear list")
sb.temp = 0
# print(other)
return HttpResponse(resp)
if (s == "clear cart" or s == "empty cart"):
cart = Cart(request)
cart.clear()
resp = "CLEARING CART"
# print(other)
return HttpResponse(resp)
resp = sb.handle(s)
# print(resp)
if type(resp) is tuple:
resp, other = resp
print(resp)
# print("***********************")
if (resp == "None"):
resp = "Done..."
else:
print(resp)
# print("***********************")
return HttpResponse(resp)
def cart_add(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
form = CartAddProductForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
cart.add(product, cd['quantity'], cd['update'])
return redirect('cart:detail')
def cart_add(request, product_id):
cart = Cart(request) # create a new cart object passing it the request object
product = get_object_or_404(Product, id=product_id)
form = CartAddProductForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
cart.add(product=product, quantity=cd['quantity'], update_quantity=cd['update'])
return redirect('cart:cart_detail')
def cart_add(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
form = CartAddProductForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
cart.add(product=product, quantity=cd['quantity'],
update_quantity=cd['update'])
return redirect('cart:cart_detail')
def get(self, request, **kwargs):
if request.is_ajax:
cart = Cart(request)
try:
product = Product.objects.get(id=kwargs['id'])
quantity = 1
cart.add(product, product.price, quantity)
return HttpResponse(json.dumps({'count': cart.count()}))
except:
return HttpResponse(json.dumps({'count': cart.count()}))
def add_to_cart(request, product_id, quantity):
if int(quantity) > 0:
product = MenuItem.objects.get(id=product_id)
cart = Cart(request)
batch_item = Menu.get_current_menu().itembatch_set.get(item=product)
if batch_item.amount >= int(quantity) + int(cart.get_qty(product)):
cart.add(product, product.retailer_price(request.session['user']), quantity)
request.session['quantity_error'] = None
request.session['quantity_error_item'] = None
return JsonResponse({"return": "ok"})
else:
request.session['quantity_error'] = batch_item.amount
request.session['quantity_error_item'] = product.name
return JsonResponse({"return": "fail"})
def add_to_cart(request, pk, q):
product = Post.objects.get(id=pk)
product.q = q
cart = Cart(request)
added_product = product
product_user = 0;
if request.user.is_authenticated():
product.q = q
request.user.post_set.add(product)
product_user = request.user.post_set
request.products = request.user.post_set.filter(user=request.user)
else:
cart.add(product, product.price, q)
return redirect('blog.views.get_cart')
def add_to_cart(request, product_id):
product = get_object_or_404(Product, id=product_id)
cart = Cart(request)
form = CartItemForm(product, request.POST, prefix=str(product.pk))
if form.is_valid():
cd = form.cleaned_data
quantity = cd.get("quantity", "1")
cart.add(product, product.price, int(quantity))
if request.is_ajax():
return JsonResponse({"success": True, "count": cart.cart.item_set.count()})
return redirect("cart-show")
else:
if request.is_ajax():
errors = dict([(k, force_text(v[0])) for k, v in form.errors.items()])
return JsonResponse({"success": False, "errors": errors})
return redirect("cart-show")
class TestCheckIn(TestCase):
def setUp(self):
# get request
rf = RequestFactory()
request = rf.get(reverse('cart-check-in'))
add_session_to_request(request)
# get cart
self.cart = Cart(request)
product = ProductFactory()
self.cart.add(product, product.price, 1)
# prepare session
self.client = Client()
engine = import_module(settings.SESSION_ENGINE)
store = engine.SessionStore()
store.save()
self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
def test(self):
data = {
"surname": "Vasiliy",
"name": "Vasya",
"phone": '092-123-45-67',
"email": '*****@*****.**',
"pay_way": "on_delivery",
"delivery_by": "newpost",
"address": "adress123",
"user_comment": "",
"agree": True,
}
# store cart id in session
session = self.client.session
session['CART-ID'] = self.cart.cart.pk
session.save()
# call check_in
resp = self.client.post(reverse('cart-check-in'), data=data)
# print resp
order = Order.objects.all().reverse()[0]
session['ORDER_PK'] = order.pk
session.save()
# check redirect
self.assertRedirects(resp, reverse('cart-order-preview'), status_code=302, target_status_code=200)
def book_detail(request,slug):
book = get_object_or_404(Book, slug= slug)
categories = Category.objects.filter(is_active=True)
related_books = Book.objects.filter(category=book.category)
#delete oneself from the filter result and get the first four result
related_books = related_books.exclude(id = book.id)[:4]
form = CartAddProductForm()
if request.method == 'POST':
form = CartAddProductForm(request.POST)
'''import pdb; pdb.set_trace()'''
if form.is_valid():
cd = form.cleaned_data
cart = Cart(request)
cart.add( book= book ,quantity = cd['quantity'])
return HttpResponseRedirect(reverse('cart:show_cart'))
else:
return render(request,'catalog/book_detail.html',{'book':book,'related_books':related_books,'categories':categories,'form':form})
def add_to_cart(request, cat_id, product_id, quantity):
product = models.Product.objects.get(id=product_id)
cart = Cart(request)
cart.add(product, product.price, quantity)
return redirect('/'+cat_id)
def add_product_to_cart(self, request, *args, **kwargs):
product = ProductPage.objects.get(id=request.POST.get('product_id'))
cart = Cart(request)
cart.add(product, product.prize, request.POST.get('quantity'))
return redirect('/order/checkout')
