def remove_total_cart(request):
if request.is_ajax():
if request.method == 'POST':
cart = Cart(request.session)
producto = Product.objects.get(id=request.POST.get('id'))
cart.remove(producto)
return HttpResponse('Eliminado')
def remove_cart(request):
if request.method == 'POST':
if request.is_ajax():
cart = Cart(request.session)
goods = Goods.objects.get(pk=request.POST.get('good'))
cart.remove(goods)
return JsonResponse({'message': "Removed"})
def remove(request):
"""
删除一个商品
"""
cart = Cart(request.session)
product = Product.objects.get(id=request.GET['id'])
cart.remove(product)
return HttpResponseRedirect('/cart/')
def cart_remove(request):
if request.is_ajax() and request.POST and 'part' in request.POST:
cart = Cart(request.session)
product = models.Part.objects.get(slug=request.POST.get('part'))
cart.remove(product)
return HttpResponse(content=product.name + " successfully removed from cart")
else:
return HttpResponse(status=400, content="Error removing from cart")
def get(self, request, *args, **kwargs):
cart = Cart(request.session)
try:
cart_item = OrderItemCart.objects.get(pk=kwargs['cart_item_id'], cart__session_key=request.session.session_key)
except OrderItemCart.DoesNotExist:
return HttpResponseRedirect(reverse('show-cart'))
cart.remove(cart_item)
cart_item.delete()
return HttpResponseRedirect(reverse('show-cart'))
def remove(request):
cart = Cart(request.session) # Get cart session
# Get product, raise error if doesn't exist
try:
product = Product.objects.get(id=request.GET.get('id'))
except Product.DoesNotExist:
raise Http404("Product does not exist")
cart.remove(product) # Remove item from cart
return redirect('shopping-cart-show') # Refresh page so item is no longer shown
def remove(request, item_id):
'''
Controller function for removing an item from the cart.
'''
cart = Cart(request.session)
product = Product.objects.get(id=item_id)
# cart.remove(product, price=product.selling_price)
cart.remove(product)
return render(request, 'cart.html', locals())
def update_cart(request):
cart = Cart(request.session)
for product in cart.products:
print product.name
qty = int(request.POST.get("product_" + str(product.id)))
if qty > 0 and qty < 100:
cart.remove(product)
cart.add(product, price=product.price, quantity=qty)
return redirect("pos:cart")
def post(self, request, *args, **kwargs):
if not request.is_ajax():
raise Http404
cart = Cart(request.session)
try:
order_cart = OrderCart.objects.get(session_key=request.session.session_key)
except OrderCart.DoesNotExist:
order_cart = OrderCart()
order_cart.session_key = request.session.session_key
order_cart.ip_address = request.META.get('REMOTE_ADDRESS', None)
order_cart.save()
software = get_object_or_404(SoftwareProduct, slug=kwargs['software_slug'])
software_modules = request.POST.get('software_modules', None)
try:
quantity = int(request.POST.get('quantity', '1'))
except ValueError:
quantity = 1
software_pricing = get_object_or_404(SoftwareProductPricing, software=software, slug=kwargs['slug'], active=True)
discount = software_pricing.software.additional_license_discount
price = software_pricing.price
software_pks = [str(software_pricing.pk)]
if software_modules:
software_modules = software_modules.split(",")
software_modules = software_pricing.active_software_modules.filter(pk__in=software_modules)
for software_module in software_modules:
software_pks.append("m_%s" % software_module.pk)
price += software_module.price
try:
order_cart_item = OrderItemCart.objects.get(cart=order_cart, software_pks=",".join(software_pks))
order_cart_item.price = price
order_cart_item.quantity = order_cart_item.quantity + quantity
quantity = order_cart_item.quantity
except OrderItemCart.DoesNotExist:
order_cart_item = OrderItemCart()
order_cart_item.cart = order_cart
order_cart_item.software_pks = ",".join(software_pks)
order_cart_item.software = software_pricing
order_cart_item.price = price
order_cart_item.quantity = quantity
order_cart_item.save()
if software_modules:
order_cart_item.modules = software_modules
if discount > 0 and quantity > 1:
additional_license_price = price - (price * discount / 100)
additional_licenses_price = additional_license_price * (quantity - 1)
price = (price + additional_licenses_price) / quantity
order_cart_item.price = price
order_cart_item.save()
cart.remove(order_cart_item)
cart.add(order_cart_item, price=order_cart_item.price, quantity=quantity)
context = self.get_context_data(**kwargs)
context.update({
'software': software,
'order_cart_item': order_cart_item
})
return self.render_to_response(context)
def carrinho_remover(request):
if request.method == 'POST':
carrinho = Cart(request.session)
produto = Produto.objects.get(pk=request.POST.get('id'))
carrinho.remove(produto)
template = loader.get_template('loja/carrinho.html')
context = RequestContext(request)
return HttpResponse(template.render(context))
else:
return HttpResponse('404')
def remove(request, product_id):
cart = Cart(request.session)
if Item2.objects.filter(product_id=product_id):
product = Item2.objects.get(product_id=product_id)
elif Item3.objects.filter(product_id=product_id):
product = Item3.objects.get(product_id=product_id)
else:
product = Item4.objects.get(product_id=product_id)
cart.remove(product)
return HttpResponseRedirect('/tohfa/show')
def post(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
cart = Cart(request.session)
product = get_object_or_404(Product, id=serializer.data['product_id'])
cart.remove(product)
response_data = {
'detail': 'Product was removed from cart.'
}
response_status = status.HTTP_200_OK
return Response(response_data, status=response_status)
def cart_action(request, action):
cart = Cart(request.session)
item_id = int(request.GET.get('item_id'))
item = MenuCollection.get(item_id)
if action == 'add':
cart.add(item, price=item.price)
messages.success(request,
'{} adicionado ao carrinho!'.format(item.name))
return HttpResponseRedirect(reverse_lazy('menu:list'))
elif action == 'remove':
cart.remove(item)
messages.success(request,
'{} removido do carrinho!'.format(item.name))
return HttpResponseRedirect(reverse_lazy('orders:cart'))
def post(self, request, **kwargs):
"""
Remove item from cart.
Args:
request: The incoming get request object
**kwargs: Any keyword arguments passed to the function
Returns:
A redirect to the deals homepage
"""
dealid = request.POST.get('dealid')
deal = Deal.objects.get(id=dealid)
cart = Cart(request.session)
cart.remove(deal)
return redirect('/')
def post(self, request, *args, **kwargs):
action = request.POST.get('action')
delete = action == 'delete'
clear = action == 'clear'
cart = Cart(request.session)
product = Product.objects.filter(
pk=request.POST.get('product')).first()
quantity = request.POST.get('quantity', 1)
if delete:
if cart.is_empty is False:
cart.remove(product)
elif clear:
if cart.is_empty is False:
cart.clear()
else:
cart.add(product, product.price, quantity)
if cart.is_empty:
return redirect('product_list')
return super().get(request, *args, **kwargs)
def update_cart(request):
cart = Cart(request.session)
if request.is_ajax():
if request.method == 'POST':
product_id = request.POST.get('id')
product_qty = request.POST['qty']
if isNum(product_id) and isNum(product_qty) and product_id > 0 and product_qty >= 0:
product = Product.objects.get(id=product_id)
try:
product_stock_count = ProductStock.objects.filter(product=product).count()
except ObjectDoesNotExist:
product_stock_count = 0
is_valid = False
#print product.availability
if (product_stock_count > 0 and int(product_qty) > 0 and product_stock_count >= int(product_qty)) or (product.availability == ProductAvailability.objects.get(name='Pre-Order') and int(product_qty) > 0) :
cart.remove(product)
#print product.price
cart.add(product, price=moneyfield_to_decimal(get_correct_price_based_on_quantity(product, int(product_qty))), quantity=product_qty)
cart_contents_qty = cart_contents_payload(request)
is_valid = True
elif int(product_qty) == 0:
cart.remove(product)
cart_contents_qty = cart_contents_payload_unique(request, True, product_id)
elif int(product_qty) > 0:
cart_contents_qty = cart_contents_payload_unique(request, True, product_id)
#elif int(product_qty) > 0 and product.availability == 'Pre-Order':
html = new_cart_html(request, product_qty)
payload = update_cart_status_and_prepare_payload(request, html, cart_contents_qty, is_valid)
return HttpResponse(json.dumps(payload), content_type="application/json")
return HttpResponseRedirect('/')
def remove(request):
cart = Cart(request.session)
selitem = Item.objects.get(id=request.GET.get('id'))
cart.remove(selitem)
return redirect(reverse('cart:shopping-cart-show'))
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('id'))
cart.remove(product)
return HttpResponse("Removed")
class CartTests(TestCase):
def setUp(self):
engine = import_module(settings.SESSION_ENGINE)
self.session = engine.SessionStore()
self.session.save()
self.client.cookies[
settings.SESSION_COOKIE_NAME] = self.session.session_key
self.factory = RequestFactory()
self.cart = Cart(self.session)
self.deer = Product.objects.create(
name='deer',
price=10.0,
custom_id=1,
)
self.moose = Product.objects.create(
name='moose',
price=20.0,
custom_id=2,
)
self.ticket = Ticket.objects.create(
name='Clint Mansell',
price=25.0,
custom_id=6,
)
def show_response(self):
"""
Utility method to return a response from the `show` view.
"""
request = self.factory.get(reverse('carton-tests-show'))
request.session = self.session
return show(request)
def test_product_is_added(self):
"""
Can a product be added to the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.session.save()
self.assertContains(self.show_response(), '1 deer for $10.0')
def test_multiple_products_are_added(self):
"""
Can multiple products be added to the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, '1 deer for $10.0')
self.assertContains(response, '1 moose for $20.0')
def test_stale_item_is_removed_from_cart(self):
"""
Are items which are not in the database kept out of the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, 'deer')
self.assertContains(response, 'moose')
self.deer.delete()
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertContains(response, 'moose')
def test_quantity_increases(self):
"""
Do multiple calls to `add` increase the quantity in the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.deer, 10.00, 2)
self.session.save()
self.assertContains(self.show_response(), '3 deer')
def test_items_are_counted_properly(self):
"""
Are items in the cart counted correctly?
"""
self.cart.add(self.deer, 10.00, 2)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, 'items count: 3')
self.assertContains(response, 'unique count: 2')
def test_products_are_removed_all_together(self):
"""
Can all products of a single type be removed?
"""
self.cart.add(self.deer, 10.00, 3)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
self.cart.remove(self.deer)
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertContains(response, 'moose')
def test_single_product_is_removed(self):
"""
Can a single instance of a product be removed?
"""
self.cart.add(self.deer, 10.00, 3)
self.session.save()
self.cart.remove_single(self.deer)
self.assertContains(self.show_response(), '2 deer')
def test_quantity_is_overwritten(self):
"""
Can an items quantity be changed?
"""
self.cart.add(self.deer, 10.00, 3)
self.session.save()
self.cart.set_quantity(self.deer, 4)
self.assertContains(self.show_response(), '4 deer')
def test_cart_items_are_cleared(self):
"""
Can a cart be entirely cleared?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.cart.clear()
self.session.save()
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertNotContains(response, 'moose')
@override_settings(CART_PRODUCT_LOOKUP={'price__gt': 1})
def test_custom_product_filter_are_applied(self):
"""
We modify the cart queryset to exclude some products. We
should not be able to add excluded products to the cart.
"""
exclude = Product.objects.create(
name='EXCLUDED',
price=0.99,
custom_id=100,
)
self.cart.add(self.deer, 10.00, 1)
self.cart.add(exclude, exclude.price, 1)
self.session.save()
response = self.show_response()
self.assertNotContains(response, 'EXCLUDE')
self.assertContains(response, 'deer')
def test_get_model_product_path(self):
"""
Is a string with the full, correct import path returned for a
model?
"""
self.assertEqual(
self.cart.get_product_model_path(self.deer),
'carton.tests.models.Product',
)
def test_different_product_models(self):
"""
Does the cart work with different models?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.ticket, 25.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, '1 deer for $10.0')
self.assertContains(response, '1 Clint Mansell for $25.0')
class CartTests(TestCase):
def setUp(self):
engine = import_module(settings.SESSION_ENGINE)
self.session = engine.SessionStore()
self.session.save()
self.client.cookies[settings.SESSION_COOKIE_NAME] = self.session.session_key
self.factory = RequestFactory()
self.cart = Cart(self.session)
self.deer = Product.objects.create(
name='deer',
price=10.0,
custom_id=1,
)
self.moose = Product.objects.create(
name='moose',
price=20.0,
custom_id=2,
)
self.ticket = Ticket.objects.create(
name='Clint Mansell',
price=25.0,
custom_id=6,
)
def show_response(self):
"""
Utility method to return a response from the `show` view.
"""
request = self.factory.get(reverse('carton-tests-show'))
request.session = self.session
return show(request)
def test_product_is_added(self):
"""
Can a product be added to the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.session.save()
self.assertContains(self.show_response(), '1 deer for $10.0')
def test_multiple_products_are_added(self):
"""
Can multiple products be added to the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, '1 deer for $10.0')
self.assertContains(response, '1 moose for $20.0')
def test_stale_item_is_removed_from_cart(self):
"""
Are items which are not in the database kept out of the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, 'deer')
self.assertContains(response, 'moose')
self.deer.delete()
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertContains(response, 'moose')
def test_quantity_increases(self):
"""
Do multiple calls to `add` increase the quantity in the cart?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.deer, 10.00, 2)
self.session.save()
self.assertContains(self.show_response(), '3 deer')
def test_items_are_counted_properly(self):
"""
Are items in the cart counted correctly?
"""
self.cart.add(self.deer, 10.00, 2)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, 'items count: 3')
self.assertContains(response, 'unique count: 2')
def test_products_are_removed_all_together(self):
"""
Can all products of a single type be removed?
"""
self.cart.add(self.deer, 10.00, 3)
self.cart.add(self.moose, 20.00, 1)
self.session.save()
self.cart.remove(self.deer)
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertContains(response, 'moose')
def test_single_product_is_removed(self):
"""
Can a single instance of a product be removed?
"""
self.cart.add(self.deer, 10.00, 3)
self.session.save()
self.cart.remove_single(self.deer)
self.assertContains(self.show_response(), '2 deer')
def test_quantity_is_overwritten(self):
"""
Can an items quantity be changed?
"""
self.cart.add(self.deer, 10.00, 3)
self.session.save()
self.cart.set_quantity(self.deer, 4)
self.assertContains(self.show_response(), '4 deer')
def test_cart_items_are_cleared(self):
"""
Can a cart be entirely cleared?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.moose, 20.00, 1)
self.cart.clear()
self.session.save()
response = self.show_response()
self.assertNotContains(response, 'deer')
self.assertNotContains(response, 'moose')
@override_settings(CART_PRODUCT_LOOKUP={'price__gt': 1})
def test_custom_product_filter_are_applied(self):
"""
We modify the cart queryset to exclude some products. We
should not be able to add excluded products to the cart.
"""
exclude = Product.objects.create(
name='EXCLUDED',
price=0.99,
custom_id=100,
)
self.cart.add(self.deer, 10.00, 1)
self.cart.add(exclude, exclude.price, 1)
self.session.save()
response = self.show_response()
self.assertNotContains(response, 'EXCLUDE')
self.assertContains(response, 'deer')
def test_get_model_product_path(self):
"""
Is a string with the full, correct import path returned for a
model?
"""
self.assertEqual(
self.cart.get_product_model_path(self.deer),
'carton.tests.models.Product',
)
def test_different_product_models(self):
"""
Does the cart work with different models?
"""
self.cart.add(self.deer, 10.00, 1)
self.cart.add(self.ticket, 25.00, 1)
self.session.save()
response = self.show_response()
self.assertContains(response, '1 deer for $10.0')
self.assertContains(response, '1 Clint Mansell for $25.0')
def remove(request):
cart = Cart(request.session)
product = cart.products[int(request.GET.get('id'))]
cart.remove(product)
return HttpResponseRedirect("/shopping/cart/")
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('id'))
cart.remove(product)
if request.is_ajax():
return HttpResponse(_("Item removed"))
def remove(request, post_id):
cart = Cart(request.session)
product = Product.objects.get(pk=post_id)
cart.remove(product)
messages.error(request, 'Prodotto Eliminato dal Carrello')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('id'))
cart.remove(product)
return redirect('shopping-cart-show')
def remove(request, id):
cart = Cart(request.session)
product = get_object_or_404(models.Product, pk=id)
cart.remove(product)
return HttpResponseRedirect('../../../card/showcard')
def remove(request):
cart = Cart(request.session)
product = products[int(request.POST.get('product_id'))]
cart.remove(product)
return HttpResponse()
def remove(request):
cart = Cart(request.session)
libro = Libro.objects.get(id=request.GET.get("id"))
cart.remove(libro)
return render(request, "show-cart.html")
def remove(request):
cart = Cart(request.session)
product = products[int(request.POST.get('product_id'))]
cart.remove(product)
return HttpResponse()
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('id'))
cart.remove(product)
return render(request, 'shopping/show-cart.html')
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(pk=request.POST.get('product_id'))
cart.remove(product)
return HttpResponse()
def remove(request, id):
cart = Cart(request.session)
product = get_object_or_404(models.Product, pk=id)
cart.remove(product)
return HttpResponseRedirect('../../../cart/showcart')
def remove(request):
cart = Cart(request.session)
product = __get_product_from_request(request)
cart.remove(product)
return render(request, 'carts/redirect.html')
def add_to_order(request):
language = "it"
session_language = "it"
if 'lang' in request.session:
session_language = request.session['lang']
if request.method == "POST":
form = AddOrderForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
cart = Cart(request.session)
post.tot_price = 0
if cart:
post.tot_price = cart.total
post.save()
cart = Cart(request.session)
for c in cart.items:
form_item = AddOrderItemForm(request.POST)
cart_item = form_item.save(commit=False)
cart_item.order = post
cart_item.product = c.product
cart_item.quantity = c.quantity
cart_item.price = c.product.price
cart_item.save()
ordine = Order.objects.get(pk=post.id)
fatturazione = Fatturazione.objects.get(user_id=request.user.id)
consegna = IndirizzoSpedizione.objects.filter(
user_id=request.user.id)
ordi = "Ordine da: " + request.user.username
subject, from_email, to = ordi, request.user.email, '*****@*****.**'
text_content = 'This is an important message.'
if session_language == 'en':
html_content = render_to_string(
'iban_emailuk.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
else:
html_content = render_to_string(
'iban_email.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
msg = EmailMultiAlternatives(subject, html_content, from_email,
[to])
msg.attach_alternative(html_content, "text/html")
msg.send()
subject, from_email, to = ordi, request.user.email, '*****@*****.**'
text_content = 'This is an important message.'
if session_language == 'en':
html_content = render_to_string(
'iban_emailuk.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
else:
html_content = render_to_string(
'iban_email.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
msg = EmailMultiAlternatives(subject, html_content, from_email,
[to])
msg.attach_alternative(html_content, "text/html")
msg.send()
subject, from_email, to = ordi, '*****@*****.**', request.user.email
text_content = 'This is an important message.'
if session_language == 'en':
html_content = render_to_string(
'iban_emailuk.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
else:
html_content = render_to_string(
'iban_email.html', {
'ordine': ordine,
'fatturazione': fatturazione,
'consegna': consegna
})
msg = EmailMultiAlternatives(subject, html_content, from_email,
[to])
msg.attach_alternative(html_content, "text/html")
msg.send()
cart = Cart(request.session)
for c in cart.items:
product_in_cart = Product.objects.get(pk=c.product.id)
cart.remove(product_in_cart)
messages.success(request, 'Ordine Effettuato')
#return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
return redirect('/customer', pk=post.pk)
else:
messages.success(
request, "Grazie di esserti loggato, ora puoi effettuare l'ordine")
#return redirect('/show-cart/')
return HttpResponseRedirect('/show-cart/')
def delete_cart_item(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('product_id'))
cart.remove(product)
return render_to_response('partial/basket_values.html', dict(cart=cart))
def remove(request):
cart = Cart(request.session)
isbn = request.POST.get("book_isbn",'')
product = Book.objects.get(isbn=isbn)
cart.remove(product)
return render(request, 'shopping/show-cart.html')
def remove_product(request, product_id):
cart = Cart(request.session)
product = Product.objects.get(pk=product_id)
cart.remove(product)
return update_cart(request)
def remove(request):
cart = Cart(request.session)
product = Submenu.objects.get(id=request.GET.get('dish_id'))
cart.remove(product)
cart.update_session()
return HttpResponse("Removed")
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('product_id'))
cart.remove(product)
return HttpResponse(cart.total)
def cart_remove(request, id):
product = m.Product.objects.get(id=id)
cart = Cart(request.session)
cart.remove(product)
return HttpResponse('success')
def remove(request, product_id):
cart = Cart(request.session)
product = Product.objects.get(pk=product_id)
cart.remove(product)
return render(request, 'shop/show-cart.html')
def remove(request):
cart = Cart(request.session)
item = Menu.objects.get(pk=request.GET.get('menu_id'))
cart.remove(item)
return HttpResponseRedirect('/menu')
def remove(request):
cart = Cart(request.session)
product = Product.objects.get(id=request.GET.get('id'))
cart.remove(product)
#return HttpResponse("Removed")
return render(request, 'pagina/eliminar-carrito.html', {'product':product})
