def check_stock(item, request, final_quantity=None, quantity_to_add=0):
"""
Check whether there is enough product to satisfy the given cart request. From the request we can get the
current number of products in their cart. If final_quantity != None then the customer is using the update_cart
form to modify their cart. If quantity_to_add > 0 then they are using the add-to-cart form to modify their cart.
A different error message is displayed in each case.
Returns None if the request is valid. Returns an error message if the request is invalid.
"""
in_stock = item.quantity
in_cart = 0
cart_item = cartutils.get_item_for_product(request, item)
if cart_item:
in_cart = cart_item.quantity
if final_quantity:
if final_quantity > in_stock:
return CartItem.get_insufficient_stock_msg(in_stock)
elif quantity_to_add > 0:
total = quantity_to_add + in_cart
if total > in_stock:
msg = CartItem.get_insufficient_stock_msg(in_stock)
if in_cart > 0:
msg += " You already have %d in your cart." % in_cart
return msg
return None
def product_detail(request, slug):
instance = get_object_or_404(Product, slug=slug)
menu_categories, cart, cart_items = initial_data(request)
images = ProductPhotos.objects.filter(product=instance)
seo_title = '%s' % instance.title
if instance.size:
form = CartItemCreateWithAttrForm(instance_related=instance)
else:
form = CartItemCreate()
if request.POST:
if instance.size:
form = CartItemCreateWithAttrForm(instance, request.POST)
if form.is_valid():
qty = form.cleaned_data.get('qty', 1)
attribute = form.cleaned_data.get('attribute')
order = check_or_create_cart(request)
CartItem.create_cart_item(request, order=order, product=instance, qty=qty, size=attribute)
messages.success(request, 'The product %s with the size %s added in your cart' % (instance.title,
attribute
)
)
return HttpResponseRedirect(reverse('product_page', kwargs={'slug': instance.slug}))
else:
form = CartItemCreate(request.POST)
if form.is_valid():
qty = form.cleaned_data.get('qty', 1)
order = check_or_create_cart(request)
CartItem.create_cart_item(request, order=order, product=instance, qty=qty)
messages.success(request, 'The product %s added in your cart' % instance.title)
return HttpResponseRedirect(reverse('product_page', kwargs={'slug': instance.slug}))
context = locals()
return render(request, 'home/product_page.html', context)
class CheckoutTestCase(TestCase):
fixtures = ['initial_data.json']
def setUp(self):
self.client = Client()
home_url = reverse('catalog_home')
self.checkout_url = reverse('checkout')
self.client.get(home_url)
#create a customer with a shopping cart
self.item = CartItem()
product = Product.active.all()[0]
self.item.product = product
self.item.cart_id = self.client.session.get(cart.CART_ID_SESSION_KEY,
'')
self.item.quantity = 1
self.item.save()
def test_checkout_page_empty_cart(self):
'''empty cart should be redirected to cart page'''
client = Client()
cart_url = reverse('show_cart')
response = client.get(self.checkout_url)
self.assertRedirects(response, cart_url)
def test_submit_empty_form(self):
'''empty form should raise error on requiered fields'''
form = CheckoutForm()
response = self.client.post(self.checkout_url, form.initial)
for name, field in form.fields.iteritems():
value = form.fields[name]
if not value and form.fields[name].required:
error_msg = form.fields[name].error_messages['required']
self.assertFormError(response, 'form', name, [error_msg])
def update_cart_items(request):
if request.method == 'GET':
return HttpResponse('no access')
elif request.method == 'POST':
cart_manager = CartManager(request)
import ast
dict_request_body = ast.literal_eval(request.body.decode("UTF-8"))
product_url = dict_request_body['product']
try:
product_id_with_slashes = re.search(r'\/[0-9]{1,6}\/', product_url).group()
product_id = re.search(r'[0-9]{1,6}', product_id_with_slashes).group()
product_id = int(product_id)
product = Product.objects.get(pk = product_id)
try:
cart_item_being_updated = CartItem.objects.get(product = product, cart = cart_manager.cart)
cart_item_being_updated.quantity += 1
cart_item_being_updated.save()
except:
# if we get here means cart item doesnt exist so we make a new one with quanitity of 1
new_cart_item = CartItem(cart = cart_manager.cart, product = product)
new_cart_item.save()
except:
HttpResponse('someone is messing with the hidden html input fields D:')
return HttpResponse('updated cart items')
def add_item_to_cart(request):
context = RequestContext(request)
user = request.user
if request.method == 'POST':
item_id = request.POST.get('item_id')
entry_id = request.POST.get('entry_id')
item = Item.objects.get(id=int(item_id))
entry = Entry.objects.get(id=int(entry_id))
user_cart = cart_exists(user, entry)
if not user_cart.is_active():
return user_cart_no_longer_active(request)
if user_cart == False:
return redirect('/cal')
else:
cart_item_to_add = CartItem(
cart=user_cart,
item=item,
qty=1)
cart_item_to_add.save()
redirect_string = "/cal/" + str(entry_id) + "/"
return redirect(redirect_string)
return redirect('/menu')
def post(self, request, *args, **kwargs):
product_id = request.POST.get('product_id')
if request.is_ajax():
if self.request.user.is_authenticated:
CartItem.save_to_cart(self.request, product_id)
else:
cart = SessionsCart(request)
product = Product.objects.get(id=product_id)
cart.add_to_cart(product=product)
return JsonResponse({'status': 'Ok'})
def cart_add(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
form = CartItem(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 add(self, product, quantity=1):
# Add a product to the cart or update its quantity.
if self.cart_item.filter(product=product):
self._update_quantity_cart(product, quantity)
else:
cart_item = CartItem(cart=self.cart,
product=product,
price=product.retail_price,
quantity=quantity)
cart_item.save()
def add(request):
if request.GET:
cart = ''
product = ''
is_exist = False
try:
cart = Cart.objects.get(id=request.session.get("cart"))
product = Product.objects.get(id=int(request.GET['pid']))
except:
raise Http404
item = CartItem()
item.product = product
item.cart = cart
item.quantity = int(request.GET['quantity'])
item.color = Color.objects.get(id=int(request.GET['color']))
item.size = Size.objects.get(id=int(request.GET['size']))
for i in CartItem.objects.filter(cart=cart).filter(product=product):
if i.is_same_spec(item):
i.quantity += item.quantity
i.save()
break
else:
item.save()
return HttpResponseRedirect("/cart/")
def setUp(self):
self.client = Client()
home_url = reverse('catalog_home')
self.checkout_url = reverse('checkout')
self.client.get(home_url)
# need to create customer with a shopping cart first
self.item = CartItem()
product = Product.active.all()[0]
self.item.product = product
self.item.cart_id = self.client.session[cart.CART_ID_SESSION_KEY]
self.item.quantity = 1
self.item.save()
def add_to_cart(request, **kwargs):
product = Product.objects.filter(id=kwargs.get('pk')).first()
cart = Cart.objects.get(user=request.user)
if product.id not in cart.cartitem_set.all().values_list(
'product', flat=True) and product.displayed and product.in_stock:
new_cart_item = CartItem(cart=cart, product=product)
new_cart_item.save()
print('ITEM ADDED TO CART')
else:
print('ITEM ALREADY IN CART')
return redirect(request.META.get('HTTP_REFERER', 'shop-home'))
def signup_user(request):
if request.user.is_authenticated:
return redirect("/")
if request.method == "POST":
try:
user = User.objects.create_user(request.POST['userName'], request.POST['email'], request.POST['password'])
user.save()
cart = CartItem(user=user, items={})
cart.save()
login(request, user)
return redirect("/")
except IntegrityError:
return render(request, "signup.html", {"error": "User name Already exist try different name"})
return render(request, "signup.html")
def add(request):
if request.GET:
cart = ''
product = ''
is_exist = False
try:
cart = Cart.objects.get(id = request.session.get("cart"))
product = Product.objects.get(id = int(request.GET['pid']))
except:
raise Http404
item = CartItem()
item.product = product
item.cart = cart
item.quantity = int(request.GET['quantity'])
item.color = Color.objects.get(id=int(request.GET['color']))
item.size = Size.objects.get(id=int(request.GET['size']))
for i in CartItem.objects.filter(cart = cart).filter(product = product):
if i.is_same_spec(item):
i.quantity+=item.quantity
i.save()
break;
else:
item.save()
return HttpResponseRedirect("/cart/")
def add_to_cart(request, pk):
user = request.user
if request.method == "POST":
form = CartItemForm(request.POST)
if form.is_valid():
new_item_data = {'product_pk': pk, 'added': False}
new_item_data = dict(new_item_data.items() +
form.cleaned_data.items())
request.session['new_item_data'] = new_item_data
if user.is_authenticated():
cart = Cart.objects.get(user=user.id)
else:
cart_pk = request.session.get('cart_pk', None)
if cart_pk is None:
cart = Cart(user=None)
cart.save()
else:
cart = Cart.objects.get(pk=cart_pk)
request.session['cart_pk'] = cart.pk
data = request.session['new_item_data']
if not data['added']:
cart_item = CartItem.from_data(cart=cart, data=data)
cart_item.save()
print "added ", cart_item, "to", cart
request.session['new_item_data']['added'] = True
request.session['new_item_data']['cart_item_pk'] = cart_item.pk
return HttpResponseRedirect(reverse("cart:new_items"))
def cart_html(request):
try:
cart_items = CartItem.current_session(cart_id=request.session['cart_id'])
except:
cart_items = []
return render_to_response('obaju/cart_item.html',{'cart_items':cart_items,
'test':2})
def post(self, request, order_id, *args, **kwargs):
"""
재주문을 하는 API
"""
try:
order_obj = Order.objects.get(id=order_id)
except Order.DoesNotExist:
return JsonResponse(status=HTTPStatus.NOT_FOUND,
data={'message': '주문 id를 찾을 수 없습니다.'})
if not order_obj.cart_id:
return JsonResponse(status=HTTPStatus.NOT_FOUND,
data={'message': '해당 주문은 요식이로 구매하였습니다.'})
user = self.request.user
new_cart = Cart.objects.create(user=user)
menu_id_list = list(
CartItem.objects.filter(cart_id=order_obj.cart_id).values_list(
'menu__id', flat=True))
cart_item_list = [
CartItem(menu_id=menu_id, cart=new_cart, quantity=1)
for menu_id in menu_id_list
]
CartItem.objects.bulk_create(cart_item_list)
return JsonResponse(status=HTTPStatus.OK,
data={'message': "재주문할 새로운 주문표를 생성하였습니다."})
def add_to_cart(request, pk):
user = request.user
if request.method == "POST":
form = CartItemForm(request.POST)
if form.is_valid():
new_item_data = {'product_pk': pk, 'added': False}
new_item_data = dict(new_item_data.items() +
form.cleaned_data.items())
request.session['new_item_data'] = new_item_data
if user.is_authenticated():
cart = Cart.objects.get(user=user.id)
else:
cart_pk = request.session.get('cart_pk', None)
if cart_pk is None:
cart = Cart(user=None)
cart.save()
else:
cart = Cart.objects.get(pk=cart_pk)
request.session['cart_pk'] = cart.pk
data = request.session['new_item_data']
if not data['added']:
cart_item = CartItem.from_data(cart=cart, data=data)
cart_item.save()
print "added ", cart_item, "to", cart
request.session['new_item_data']['added'] = True
request.session['new_item_data']['cart_item_pk'] = cart_item.pk
return HttpResponseRedirect(
reverse("cart:new_items"))
def cart_detail(request):
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartItem(initial={
'quantity': item['quantity'],
'update': True
})
return render(request, 'cart/detail.html', {'cart': cart})
def product_detail(request, slug):
instance = get_object_or_404(Product, slug=slug)
menu_categories, cart, cart_items = initial_data(request)
images = ProductPhotos.objects.filter(product=instance)
seo_title = '%s' % instance.title
if instance.size:
form = CartItemCreateWithAttrForm(instance_related=instance)
else:
form = CartItemCreate()
if request.POST:
if instance.size:
form = CartItemCreateWithAttrForm(instance, request.POST)
if form.is_valid():
qty = form.cleaned_data.get('qty', 1)
attribute = form.cleaned_data.get('attribute')
order = check_or_create_cart(request)
CartItem.create_cart_item(request,
order=order,
product=instance,
qty=qty,
size=attribute)
messages.success(
request,
'The product %s with the size %s added in your cart' %
(instance.title, attribute))
return HttpResponseRedirect(
reverse('product_page', kwargs={'slug': instance.slug}))
else:
form = CartItemCreate(request.POST)
if form.is_valid():
qty = form.cleaned_data.get('qty', 1)
order = check_or_create_cart(request)
CartItem.create_cart_item(request,
order=order,
product=instance,
qty=qty)
messages.success(
request,
'The product %s added in your cart' % instance.title)
return HttpResponseRedirect(
reverse('product_page', kwargs={'slug': instance.slug}))
context = locals()
return render(request, 'home/product_page.html', context)
def post(self, request):
cart_id = request.session.get("cart_id")
data = json.loads(request.body)
items = data['items']
if not items:
print("List empty")
else:
if cart_id == None:
cart = Cart()
cart.user = User.objects.get(id=data['user'])
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
else:
cart = Cart.objects.get(id=cart_id)
for item in items:
cart_item = CartItem()
cart_item.cart = cart
cart_item.item = get_object_or_404(Product.objects.all(),pk=item['itemid'])
cart_item.quantity = item['quantity']
cart_item.save()
cart.items.add(cart_item)
cart.save()
# data = serializers.serialize('json', [cart,])
# struct = json.loads(data)
# data = json.dumps(struct[0])
data = CartSerializer(Cart.objects.get(id=cart.id)).data
# data2 = CartItemSerializer(cart.cartitem_set.all()).data
# print (d)
return Response({'data':data})
def add_to_cart(request):
""" function that takes a POST request and adds a product instance to the current customer's shopping cart """
postdata = request.POST.copy()
# get product slug from post data, return blank if empty
product_slug = postdata.get('product_slug', '')
# get quantity added, return 1 if empty
quantity = postdata.get('quantity', 1)
# fetch the product or return a missing page error
p = get_object_or_404(Product, slug=product_slug)
# get products in cart
cart_products = get_cart_items(request)
product_in_cart = False
# check to see if item is already in cart
for cart_item in cart_products:
if cart_item.product.id == p.id:
# update the quantity if found
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
# create and save a new cart item
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def add_product_with_attr_to_cart(request, slug):
cart = check_or_create_cart(request)
qty = request.POST.get('qty', None)
attribute = request.POST.get('attribute', None)
product = get_object_or_404(Product, slug=slug)
result, message = CartItem.create_cart_item(cart, product, int(qty),
attribute)
messages.success(request, message)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def add_to_cart(request):
postdata = request.POST.copy()
product_slug = postdata.get('product_slug', '')
quantity = postdata.get('quantity', 1)
added_product = get_object_or_404(Product, slug=product_slug)
cart_products = get_cart_items(request)
product_in_cart = False
for cart_item in cart_products:
if cart_item.product.id == added_product.id:
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
new_cart_item = CartItem()
new_cart_item.product = added_product
new_cart_item.cart_id = _cart_id(request)
new_cart_item.save()
def form_valid(self, form):
product = get_object_or_404(Product, slug=self.kwargs['slug'])
qty = form.cleaned_data.get('qty', 1)
attribute_id = self.request.POST.get('attribute', None)
cart = check_or_create_cart(self.request)
result, message = CartItem.create_cart_item(cart, product, qty,
attribute_id)
messages.success(self.request, message)
return super(ProductView, self).form_valid(form)
def dispatch(self, request, *args, **kwargs):
items = request.POST.getlist('item', None)
user = request.user
r = Favorite.objects.filter(user=user, item__in=items)
if 'remove' in request.POST:
r.delete()
if 'add2cart' in request.POST:
cart = get_current_cart(request)
for item_id in items:
item = Item.objects.get(id=item_id)
try:
cart_item = CartItem.objects.filter(cart=cart,
item=item)[0]
cart_item.quantity += 1
except IndexError:
cart_item = CartItem(cart=cart, item=item, quantity=1)
cart_item.save()
r.delete()
return super(ActionView, self).dispatch(request, *args, **kwargs)
def add_item(request):
product_id = request.POST.get("product_id", None)
product = get_object_or_404(Product, id=product_id)
if request.method == "POST" and request.is_ajax():
if product.has_options and product.parent == None:
return JsonResponse({"message": _("Please choose a size")})
cart = get_cart(request)
quantity = request.POST.get("quantity")
if not quantity:
quantity = 1
quantity = int(quantity)
if product.stock >= quantity:
try:
item = CartItem.objects.get(product=product, cart=cart)
except CartItem.DoesNotExist:
item = CartItem()
item.cart = cart
item.product = product
discount = 0
if product.discountable:
discount = product.get_discount_price() * quantity
gross = product.price * quantity
item.quantity += int(quantity)
item.discount_total += discount
item.gross_total += gross
item.net_total += gross - discount
item.save()
cart.discount_total += discount
cart.gross_total += gross
cart.net_total += gross - discount
cart.save()
product.stock -= quantity
product.save()
items = CartItem.objects.filter(cart=cart)
return render(request, "cart/index-ajax.html", {"cart": cart, "items": items})
return JsonResponse({"message": _("This item has sold out")})
def post(self, request, *args, **kwargs):
cart = self.get_object()
product_id = int(request.POST.get("item"))
qty = int(request.POST.get("qty", 1))
if product_id is not None:
product = get_object_or_404(Product, pk=product_id)
message = request.POST.get("request_message", "")
print("Request msg: " + str(message))
if qty < 1:
data = {
'success': False,
'errorMsg': 'Quantity cannot be less than 1',
'errorCode': '400'
}
else:
cart_item = CartItem(cart=cart, product=product)
cart_item.quantity = qty
cart_item.intention = message
cart_item.save()
data = {'success': True}
else:
data = {
'success': False,
'errorMsg': 'Item id not provided',
'errorCode': '400'
}
return JsonResponse(data=data)
def add_to_cart(request):
""" function that takes a POST request and adds a product instance to the current customer's shopping cart """
postdata = request.POST.copy()
# get product slug from post data, return blank if empty
product_slug = postdata.get('product_slug','')
# get quantity added, return 1 if empty
quantity = postdata.get('quantity',1)
# fetch the product or return a missing page error
p = get_object_or_404(Product, slug=product_slug)
#get products in cart
cart_products = get_cart_items(request)
product_in_cart = False
# check to see if item is already in cart
for cart_item in cart_products:
if cart_item.product.id == p.id:
# update the quantity if found
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
# create and save a new cart item
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
print("AGGGGG")
request.session['items_total'] = get_total_number(request)
print(request.session['items_total'])
print("DANK MEMES")
def detail(request, product_id):
product = Product.objects.get(pk=product_id)
if request.method == 'POST':
form = CartItemForm(request.POST)
if form.is_valid():
user = User.objects.get(username=request.user)
try:
cart = Cart.objects.get(user=user)
except Cart.DoesNotExist:
cart = Cart()
cart.user = user
cart.save()
item = CartItem()
item.product = product
item.quantity = form.cleaned_data['quantity']
item.save()
cart.item.add(item)
return redirect('products:index')
else:
form = CartItemForm()
return render(request, 'products/detail.html', {
'form': form,
'product': product
})
class CheckoutTestCase(TestCase):
""" tests checkout form page functionality """
def setUp(self):
self.client = Client()
home_url = reverse('catalog_home')
self.checkout_url = reverse('checkout')
self.client.get(home_url)
# need to create customer with a shopping cart first
self.item = CartItem()
product = Product.active.all()[0]
self.item.product = product
self.item.cart_id = self.client.session[cart.CART_ID_SESSION_KEY]
self.item.quantity = 1
self.item.save()
def test_checkout_page_empty_cart(self):
""" empty cart should be redirected to cart page """
client = Client()
cart_url = reverse('show_cart')
response = client.get(self.checkout_url)
self.assertRedirects(response, cart_url)
def test_checkout_page(self):
""" with at least one cart item, request for checkout page URL is successful """
response = self.client.get(self.checkout_url)
self.assertEqual(response.status_code, http.HTTPStatus.OK)
self.assertContains(response, "Checkout")
url_entry = resolve(self.checkout_url)
template_name = url_entry[2]['template_name']
self.assertTemplateUsed(response, template_name)
def test_submit_empty_form(self):
""" empty order form raises 'required' error message for required order form fields """
form = CheckoutForm()
response = self.client.post(self.checkout_url, form.initial)
for name, field in form.fields.iteritems():
value = form.fields[name]
if not value and form.fields[name].required:
error_msg = form.fields[name].error_messages['required']
self.assertFormError(response, "form", name, [error_msg])
def add(self, goodsid, colorid, sizeid, count, *args, **kwargs):
# 获取购物项的唯一标示
key = self.__get_key(goodsid, colorid, sizeid)
# session {'cart':{key1:item}}
# session('cart',[{key1:cartitem,key2:cartitem}])
if key in self.session[self.cart_name]:
self.update(goodsid, colorid, sizeid, count, *args, **kwargs)
else:
self.session[self.cart_name][key] = CartItem(goodsid=goodsid, colorid=colorid, sizeid=sizeid, count=count)
def product_add(request, p_id):
if not request.user.is_authenticated:
return redirect("/login")
cart = CartItem.get_or_create(request.user)
try:
if p_id not in cart.items:
cart.items.update({p_id: 1})
cart.products.add(p_id)
cart.save()
except TypeError:
cart.items = {p_id: 1}
cart.products.add(p_id)
cart.save()
return HttpResponse("added")
def add(request):
if request.method == "POST" and request.user.is_authenticated:
profile = Profile.objects.filter(user=request.user)[0]
cart = list(
filter(lambda x: x.is_active,
Cart.objects.filter(profile=profile)))
cartItem = CartItem()
if len(cart) > 0:
cartItem.cart = cart[0]
else:
cart = Cart()
cart.profile = profile
cart.total = 0.0
cart.save()
cartItem.cart = cart
cartItem.quantity = int(request.POST.get('id_quantity'))
cartItem.material = request.POST.get('id_material')
cartItem.good = Good.objects.get(id=request.POST.get('id_good_id'))
cartItem.save()
return redirect('/good/{0}'.format(request.POST.get('id_good_id')))
else:
return HttpResponseBadRequest()
def add_orderitem_to_cart(orderitem, request):
quantity = orderitem.quantity
p = get_object_or_404(Product, slug=orderitem.product.slug)
cart_products = get_cart_items(request)
product_in_cart = False
for cart_item in cart_products:
if cart_item.product.id == p.id:
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def add_to_cart(request):
postdata = request.POST.copy()
product_id = postdata.get('product_id')
quantity = postdata.get('quantity', 1)
size_id = postdata.get('size_id', 1)
p = get_object_or_404(Flower, id=product_id)
s = get_object_or_404(Size, id=size_id)
products = get_cart_items(request)
in_cart = False
for item in products:
if item.product.id != p.id and item.size.id != s.id:
item.augment_quantity(quantity)
in_cart = True
if not in_cart:
item = CartItem()
item.product = p
item.quantity = quantity
item.cart_id = _cart_id(request)
item.size = s
item.save()
def add_to_cart(request):
postdata = request.POST.copy()
product_slug = postdata.get('product_slug', '')
print('add_to_cart')
quantity = postdata.get('quantity', 1)
p = get_object_or_404(Product, slug=product_slug)
cart_products = get_cart_items(request)
product_in_cart = False
for cart_item in cart_products:
if cart_item.product.id == p.id:
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def add_to_cart(request):
postdata = request.POST.copy()
product_id = postdata.get('product_id')
quantity = postdata.get('quantity', 1)
size_id = postdata.get('size_id', 1)
p = get_object_or_404(Flower, id=product_id)
s = get_object_or_404(Size, id=size_id)
products = get_cart_items(request)
in_cart = False
for item in products:
if item.product.id != p.id and item.size.id != s.id:
item.augment_quantity(quantity)
in_cart = True
if not in_cart:
item = CartItem()
item.product = p
item.quantity = quantity
item.cart_id = _cart_id(request)
item.size = s
item.save()
def add_to_cart(request):
postdata = request.POST.copy()
product_slug = postdata.get('product_slug', '')
quantity = postdata.get('quantity', 1)
p = get_object_or_404(Product, slug=product_slug)
cart_products = get_cart_items(request)
product_in_cart = False
for item in cart_products:
if item.product.id == p.id:
item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def post(self, request, *args, **kwargs):
""" If request is POST, redirect to cart list page
"""
cart = self.get_object()
product_id = int(request.POST.get("item"))
qty = int(request.POST.get("qty", 1))
if product_id is not None:
product = get_object_or_404(Product, pk=product_id)
message = request.POST.get("request_message", "")
# print("Request msg: " + str(message))
cart_item = CartItem(cart=cart, product=product)
cart_item.quantity = qty
cart_item.intention = message
if "request_attachment" in request.FILES:
cart_item.attachment = request.FILES["request_attachment"]
cart_item.save()
return HttpResponseRedirect(reverse('cart:list'))
def add_to_cart(request):
postdata = request.POST.copy()
# get product slug from post data, return blank if empty
product_slug = postdata.get("product_slug", "")
# get quantity added, return 1 if empty
quantity = postdata.get("quantity", 1)
# fetch the product or return a missing page error
p = get_object_or_404(Product, slug=product_slug)
# get products in cart
cart_products = get_cart_items(request)
product_in_cart = False
# check to see if item is already in cart
for cart_item in cart_products:
if cart_item.product.id == p.id:
# update the quantity if found
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
# create and save a new cart item
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def add_to_cart(request):
postdata = request.POST.copy()
# get product slug from post data, return blank if empty
product_slug = postdata.get('product_slug', '')
# get quantity added, return 1 if empty
quantity = postdata.get('quantity', 1)
# fetch the product or return a missing page error
p = get_object_or_404(Product, slug = product_slug)
# get products in cart
cart_products = get_cart_items(request)
product_in_cart = False
# check to see if item is already in cart
for cart_item in cart_products:
if cart_item.product.id == p.id:
# update the quantity if found
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
# create and save a new cart item
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
def checkout_auto_renewal(request):
"""for admin charging of auto renews"""
customer = request.POST.get('ccStripeId', "")
record_id = request.POST.get('recordId', "")
user_id = request.POST.get('userId', "")
issue = request.POST.get('issueNo', "")
cc = CreditCard.objects.get(stripe_id=customer)
user = User.objects.get(id=user_id)
record = Record.objects.get(id=record_id)
sub = Subscription.objects.get(sku="pbrenewal")
cart = Cart(user=user)
cart.save()
cart_item = CartItem(cart=cart,
subscription=sub,
flug=sub.slug,
line_total=sub.price,
recipient=record.recipient,
)
cart_item.save()
cart.product_total = cart_item.line_total
cart.total = cart_item.line_total
cart.save()
order=Order(cart=cart,
user=user,
total=cart.total,
payer_name=user.get_full_name(),
payer_email=user.email,
)
order.order_id = id_generator()
order.save()
amount = int(order.total * 100) # convert to cents
fee = int(order.total * 100 * settings.TRINITY_FEE * .01) # % of inputed ($) amount, in cents
try:
charge = stripe.Charge.create(
amount=amount, # amount in cents, again
currency="usd",
application_fee=fee,
customer=customer,
api_key=settings.TRINITY_API_KEY,
)
order.status = "Finished"
order.last4 = cc.last4
order.card_type = cc.card_type
order.save()
recipient = record.recipient
last_record = Record.objects.filter(recipient=recipient).order_by('issue').last()
ish = last_record.issue + 1
# try:
# all_record = Record.objects.get(recipient=sub.recipient, originating_order=order, issue=ish)
for x in range(0, cart_item.subscription.term):
try:
record = Record.objects.get(recipient=recipient, originating_order=order, issue=ish)
pass
except Record.DoesNotExist:
new_record = Record(recipient=recipient, originating_order=order, issue=ish)
new_record.save()
ish += 1
order.status = "Recorded"
order.save()
# now we notify.
subbies = CartItem.subbie_type.filter(cart=cart)
current_site = Site.objects.get_current()
local = settings.LOCAL
email_context = {
"cart": cart,
"subbies": subbies,
"order": order,
"current_site": current_site,
"local": local,
}
if settings.EMAIL_NOTIFICATIONS is True:
recipient = order.payer_email
print "email notifications are true and we're about to send to %s" % recipient
purchase_notify(email_context, recipient)
else:
print "email settings not true"
pass
except stripe.CardError, e:
# Since it's a decline, stripe.error.CardError will be caught
body = e.json_body
err = body['error']
print "Status is: %s" % e.http_status
print "Type is: %s" % err['type']
print "Code is: %s" % err['code']
print "Message is: %s" % err['message']
messages.error(request, "%s The payment could not be completed." % err['message'])
return CartItem.objects.filter(cart_id=_cart_id(request))
#add an item to the cart
def add_to_cart(request):
postdata = request.POST.copy()
# get product slug from post data, return blank if empty
product_slug = postdata.get('product_slug', '')
# get quantity added, return 1 if empty
quantity = postdata.get('quantity', 1)
# fetch the product or return a missing page error
p = get_object_or_404(Product, slug=product_slug)
#get products in cart
cart_products = get_cart_items(request)
product_in_cart = False
# check to see if item is already in cart
for cart_item in cart_products:
if cart_item.product.id = p.id:
# update the quantity if found
cart_item.augment_quantity(quantity)
product_in_cart = True
if not product_in_cart:
# create and save a new cart item
ci = CartItem()
ci.product = p
ci.quantity = quantity
ci.cart_id = _cart_id(request)
ci.save()
# returns the total number of items in the user's cart
def cart_distinct_item_count(request):
return get_cart_items(request).count()
def cart_add(request, restaurant_slug,
meal_slug, size, template_name="cart.html"):
nameRestaurant = Restaurant.objects.filter(slug=restaurant_slug)
meal = MenuPosition.objects.filter(
slug=meal_slug, restaurant=nameRestaurant[0])
cart = Cart.objects.filter(user=request.user.id, ordered=False)
if cart:
size = Size.objects.filter(size=size, name=meal[0].id)
ci = CartItem()
ci.product = size[0]
ci.quantity = 1
ci.cart_id = cart[0]
ci.save()
else:
new_cart = Cart()
new_cart.user = request.user
new_cart.save()
size = Size.objects.filter(size=size, name=meal[0].id)
ci = CartItem()
ci.product = size[0]
ci.quantity = 1
ci.cart_id = new_cart
ci.save()
return redirect("/my_cart/")
