def CartRemove(request, category_id, product_id):
"""Удалить товар из корзины"""
cart = Cart(request)
product = Category.get_object_by_id_category(category_id, product_id)
cart.remove(product)
return redirect('cart:CartDetail')
pass
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 checkout(request):
cart = Cart(request)
if len(cart.cart) == 0:
return redirect('/')
contact_form = CheckoutContactForm()
products_in_basket = cart.cart
if request.method == 'POST':
data = request.POST
contact_form = CheckoutContactForm(request.POST or None)
if contact_form.is_valid():
email = contact_form.cleaned_data['email']
phone = contact_form.cleaned_data['phone']
user = None
if request.user.is_authenticated:
user = User.objects.get(email=request.user.email)
order = Order.objects.create(email=email,
phone=phone,
status_id=1,
user=user)
for item in data:
if len(item.split('product_in_basket_')) == 1:
continue
id = item.split('product_in_basket_')[1]
product = get_object_or_404(Product, id=id)
ProductInOrder.objects.create(product=product,
order=order,
count=data[item])
cart.del_all()
return redirect(reverse('landing:home'))
return render(request, 'orders/checkout.html', locals())
def make_order_view(request): # формирование (создание, заполнение) заказа
try:
cart_id = request.session['cart_id']
cart = Cart.objects.get(id=cart_id)
request.session['total'] = cart.items.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.objects.get(id=cart_id)
categories = Category.objects.all()
form = OrderForm(request.POST or None)
if form.is_valid():
name = form.cleaned_data['name']
last_name = form.cleaned_data['last_name']
phone = form.cleaned_data['phone']
buying_type = form.cleaned_data['buying_type']
address = form.cleaned_data['address']
comments = form.cleaned_data['comments']
new_order = Order.objects.create(user=request.user,
items=cart,
total=cart.cart_total,
first_name=name,
last_name=last_name,
phone=phone,
address=address,
buying_type=buying_type,
comments=comments)
del request.session['cart_id']
del request.session['total']
return HttpResponseRedirect(reverse('thank_you'))
return render(request, 'order/order.html', {'categories': categories})
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
})
def get_user_cart(request):
try:
cart = Cart.objects.get(user=request.user)
except Cart.DoesNotExist:
cart = Cart(user=request.user)
cart = cart.save()
return cart
def signup(request):
if request.method == 'GET':
return render(request, 'accounts/signup.html')
else:
username = request.POST['username']
email = request.POST['email']
password1 = request.POST['password1']
password2 = request.POST['password2']
phone = request.POST['phone']
state = request.POST['state']
city = request.POST['city']
address = request.POST['address']
try:
u = User.objects.get(username=username)
except:
u = None
if u:
return HttpResponseRedirect(reverse('signup'))
else:
if password1 == password2:
user = User.objects.create_user(username, email, password1)
user.save()
profile = Profile(user=user,
phonenumber=phone,
state=state,
city=city,
address=address)
profile.save()
cart = Cart(user=user)
cart.save()
return HttpResponseRedirect(reverse('login'))
else:
return HttpResponseRedirect(reverse('signup'))
def get_cart(request):
if 'cart_id' in request.session:
cart = Cart.get_cart(request.session['cart_id'])
else:
cart = Cart.get_cart()
request.session['cart_id'] = cart.id
return cart
def addtocart(request, id):
userid = request.user.id
bookid = id
book = Book.objects.get(id=bookid)
cartcheck = Cart.objects.filter(userid=userid)
already = False
for data in cartcheck:
if (bookid == data.bookid):
already = True
if (userid == book.bookowner):
return render(request, 'ownbook.html')
if (already):
# return render(request,'home.html',{'already':'success'})
return redirect('homepage')
else:
cart = Cart(userid=userid,
bookid=bookid,
bookname=book.bname,
price=book.display_selling_price,
image=book.image,
slug=book.slug)
cart.save()
# return render(request,"home.html",{'msg':'success'})
return redirect('homepage')
def signup(request):
if request.method == "POST":
if request.POST['password1'] == request.POST['password2']:
try:
user = User.objects.get(username=request.POST['username'])
return render(request, 'accounts/signup.html',
{'error': 'User already exist'})
except User.DoesNotExist:
user = User.objects.create_user(
username=request.POST['username'],
password=request.POST['password1'])
cart = Cart(user=request.POST['username'], cartitem=[[0]])
add = Add(uname=request.POST['username'])
add.save()
cart.save()
return redirect('home')
else:
return render(request, 'accounts/signup.html',
{'error': 'Password does not match'})
else:
return render(request, 'accounts/signup.html')
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
if cart.coupon:
order.coupon = cart.coupon
order.discount = cart.coupon.discount
order.save()
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
# clear the cart
cart.clear()
# launch asynchronous task
order_created.delay(order.id)
return render(request, 'orders/order/created.html',
{'order': order})
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def show_products(request):
if request.method == 'POST':
qty = request.POST['qty']
pid = request.POST['pid']
p = Product.objects.get(id=pid)
aqty = int(p.qty)
if qty != '':
oqty = int(qty)
if oqty > aqty:
return HttpResponse('stock not available')
else:
user = request.user
product = Product.objects.get(id=pid)
date = datetime.now()
qty = qty
b = Cart(user=user, product=product, date=date, qty=qty)
b.save()
product.qty = product.qty - int(qty)
product.save()
return HttpResponse('<script>alert("Added to cart")</script>')
# return redirect(f'../book/{pid}/{qty}')
else:
return HttpResponse('enter quantity')
products = Product.objects.all()
return render(request, 'products.html', {'products': products})
def test_cart_detail(self):
url_detail = reverse('cart_detail_api', args=(self.item.id,))
url_detail_with_fake_id = reverse('cart_detail_api', args=(self.fake_id,))
url = reverse('cart_list')
post = {'item': self.item.id}
# create cart
cart = Cart(user=self.user1, item=self.item)
cart.save()
# get,post by anonymous user
response = self.client.get(url_detail)
self.assertEqual(response.status_code, 403)
# get,post by auth user
self.client.login(username='******', password='******')
# Add item to the cart
self.client.post(url, post)
response = self.client.get(url_detail)
self.assertEqual(response.status_code, 200)
# Get to non exists cart detail
response = self.client.get(url_detail_with_fake_id)
self.assertEqual(response.status_code, 404)
def login(request):
"""Return a login page"""
if request.user.is_authenticated:
return redirect(reverse('index'))
if request.method == "POST":
login_form = UserLoginForm(request.POST)
if login_form.is_valid():
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password'])
if user:
auth.login(user=user, request=request)
messages.success(request, "You have successfully logged in!")
# Check if user has a cart, create it if necessary
try:
cart_get = Cart.objects.get( # Gets an existing cart
user=user)
for cartLineItem in cart_get.cartlineitem_set.all():
print(cartLineItem)
except Cart.DoesNotExist:
cart_get = Cart(user=user)
cart_get.save() # Create a new Cart
request.session['cart'] = model_to_dict(cart_get)
return redirect(reverse('index'))
else:
login_form.add_error(None, "Your username or password is incorrect")
else:
login_form = UserLoginForm()
return render(request, 'login.html', {'login_form': login_form})
def order_create(request, total=0):
cart = Cart(request)
if request.method == 'POST':
form = IEPostalAddressForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
if cart.voucher:
order.voucher = cart.voucher
order.discount = cart.voucher.discount
if request.user.is_authenticated:
username = str(request.user.username)
order.username = username
order = form.save()
order.save()
for order_item in cart:
OrderItem.objects.create(order=order,
product=order_item['product'],
price=order_item['price'],
quantity=order_item['quantity'])
cart.clear()
total = Cart.get_total_price_after_discount(cart)
Email.sendOrderConfirmation(request, order.emailAddress, order.id,
order.addressline1, order.addressline2,
order.code, order.city, order.county,
order.country, total)
return render(request, 'order_created.html', {
'order': order,
'total': total
})
else:
form = IEPostalAddressForm()
return render(request, 'order.html', {'cart': cart, 'form': form})
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 test_cart_detail(self):
url_detail = reverse('cart_detail_api', args=(self.item.id, ))
url_detail_with_fake_id = reverse('cart_detail_api',
args=(self.fake_id, ))
url = reverse('cart_list')
post = {'item': self.item.id}
# create cart
cart = Cart(user=self.user1, item=self.item)
cart.save()
# get,post by anonymous user
response = self.client.get(url_detail)
self.assertEqual(response.status_code, 403)
# get,post by auth user
self.client.login(username='******', password='******')
# Add item to the cart
self.client.post(url, post)
response = self.client.get(url_detail)
self.assertEqual(response.status_code, 200)
# Get to non exists cart detail
response = self.client.get(url_detail_with_fake_id)
self.assertEqual(response.status_code, 404)
def get_anonymous_cart(request, session):
try:
cart = Cart.objects.get(session__session=session, user=None)
except Cart.DoesNotExist:
cart = Cart(session=AnonymousSession.objects.get(session=session))
cart = cart.save()
return cart
def update_cart(request, pk):
request.session.set_expiry(1200) # seconds
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
request.session['cart_id'] = cart.id
try:
meal = RestaurantMeals.objects.get(pk=pk)
except RestaurantMeals.DoesNotExist:
pass
if not meal in cart.products.all():
cart.products.add(meal)
meal.is_eatable = False #change the state of the meal so it is not visible for search
meal.save()
else:
cart.products.remove(meal)
meal.is_eatable = True #change the state of the meal so it is visible for search
meal.save()
updated_total = 0.00
for meal in cart.products.all():
updated_total += float(meal.price)
request.session['meals_total'] = cart.products.count()
cart.total = updated_total
cart.save()
return HttpResponseRedirect(reverse('cart'))
def auction_checkcart(request):
if request.method == 'GET':
auctions = Auction.objects.filter(valid=True,
exp_time__lt=datetime.now())
serializerAuction = AuctionSerializer(auctions, many=True)
for auction in auctions:
itemId = auction.product_id
lastest_price = auction.lastest_price
try:
cart = Cart.objects.get(customer_id=auction.customer_id)
except:
cart = Cart(customer_id=auction.customer_id,
time=datetime.now())
cart.save()
cartProduct = CartProduct(cart_id=cart.id,
product_id=itemId,
price=lastest_price,
quantity=1,
time=datetime.now())
cartProduct.save()
Auction.objects.filter(pk=auction.id).update(valid=False)
return JsonResponse(serializerAuction.data, status=200, safe=False)
def user_login(request):
if request.user.is_authenticated: # если пользователь авторизован редиректим на главную
return redirect(reverse('general:index'))
if request.method == 'POST': # если запрос на вход
next_page = request.POST.get('next') # для редиректа после авторизации
form = UserLoginForm(request, data=request.POST)
if form.is_valid():
cd = form.cleaned_data
user = authenticate(username=cd['username'], password=cd['password']) # пробуем войти
if user is not None:
if user.is_active: # успешный вход
login(request, user)
cart = Cart(request, first_login=True)
if cd['merge']: # синхронизируем корзину с БД
cart.set_order_from_session()
messages.info(request, "Авторизация прошла успешно")
redirect_url = settings.LOGIN_REDIRECT_URL if not next_page else next_page
return redirect(redirect_url)
else: # вход не очень успешный :(
return HttpResponse('Disabled account')
else:
form = UserLoginForm(request)
next = request.GET.get('next') if request.GET.get('next') else ''
context = {'form': form, 'next': next}
return render(request, 'auth_v2/login.html', context)
def post(self, request):
# check if a cart exists in 'session'
# if not, create cart w/ guest owner
# if user decides to login
# need to retrieve the cart in 'session'
# and assign the user as 'owner'
new_cart = Cart()
new_cart.save()
added_product = Product.objects.get(pk=request.body)
new_cart.products.add(added_product)
serialized_cart = CartModelSerializer(new_cart)
# print('the serialized cart', serialized_cart)
# print('the serialized cart data', serialized_cart.data)
return Response(serialized_cart.data)
def update_cart(request, slug):
request.session.set_expiry(3000)
#qty = request.POST['qty']
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
subscription = Subscription.objects.get(slug=slug)
cart_item = CartItem.objects.create(cart=cart, subscription=subscription, flug=slug)
cart_item.line_total = subscription.price
print "line total is %s " % cart_item.line_total
cart_item.save()
calc_cart_shipping_total(cart.id)
calc_cart_total(request, cart.id)
return HttpResponseRedirect(reverse("view_cart"))
def add_renewal_to_cart(request, slug, recipient_id):
request.session.set_expiry(3000)
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
if request.method == "POST":
print "we got post add renewal to cart"
try:
print "we got post and add renewal"
subscription = Subscription.objects.get(slug=slug)
print subscription
recipient = Recipient.objects.get(id=recipient_id)
print recipient
# check if renewal item of same recip is in cart already
items = CartItem.objects.filter(cart=cart)
print items
for item in items:
if recipient == item.recipient and item.subscription:
print "already in cart!"
messages.error(request,
"This renewal is already in your cart. <a href='/cart/'>View Cart</a>",
extra_tags='safe')
return HttpResponseRedirect(reverse("dashboard"))
else:
pass
cart_item = CartItem.objects.create(cart=cart, subscription=subscription, flug=slug, recipient=recipient)
print cart_item
cart_item.line_total = subscription.price
print "line total is %s " % cart_item.line_total
last_record = Record.objects.filter(recipient=recipient).order_by('issue').last()
begin_issue = last_record.issue + 1
print "first issue is %s" % begin_issue
cart_item.begin_date = issue_date(begin_issue)
cart_item.save()
except:
print "other"
# error message
return HttpResponseRedirect(reverse("view_cart"))
calc_cart_shipping_total(cart.id)
calc_cart_total(request, cart.id)
# success message
request.session['items_total'] = cart.cartitem_set.count()
return HttpResponseRedirect(reverse("view_cart"))
return HttpResponseRedirect(reverse("view_cart"))
def orderdetails(request):
previous_route = request.META.get("HTTP_REFERER", None)
matcing_url = request.get_full_path
cart_id = request.session.get("sessionid", None)
anonymous_email = request.session.get("anonymoususer", None)
user = request.user
if previous_route:
if request.user.is_authenticated and cart_id is not None:
try:
cart_obj_for_register_user = Cart.objects.get(id=cart_id)
cart_obj_for_register_user.user = request.user
cart_obj_for_register_user.save()
try:
billing_obj = BillingProfileforRegisterUser.objects.get(
user__id=request.user.id)
orders_obj, created = OrderForRegisterUser.objects.update_or_create(
cart=Cart(id=cart_id),
defaults={
"billing_profile_register_user": billing_obj
})
cart = Cart.objects.get(id=cart_id)
subtotal = cart.subtotals
total = cart.total
product = cart.product.all()
except ObjectDoesNotExist:
print(
"billing object has not been created yet for authenticated users"
)
except ObjectDoesNotExist:
print(" Cart doesn't exists ")
else:
try:
cart_obj_for_anonymus_user = Cart.objects.get(id=cart_id)
try:
billing_obj = BillingProfileForAnonymous.objects.get(
email=anonymous_email)
orders_obj, created = OrderForAnonymusUser.objects.update_or_create(
cart=Cart(id=cart_id),
defaults={"billing_profile_anynous_user": billing_obj})
cart = Cart.objects.get(id=cart_id)
subtotal = cart.subtotals
total = cart.total
product = cart.product.all()
except ObjectDoesNotExist:
print("billing object for anonymus user doesn't exists")
except ObjectDoesNotExist:
print("cart doesn't exist for anonymus user")
a = orders_obj
request.session["order_id"] = orders_obj.order_id
context = {
"order_info": orders_obj,
"product": product,
"total": total,
"subtotal": subtotal
}
return render(request, "order/orderdetails.html", context)
return redirect("cart:cartitem")
def _create_cart():
"""
: private access
create and returns a cart object
"""
cart = Cart(ticket = str(uuid.uuid4()))
cart.save()
return cart
def addToCart(request):
uid = request.GET['uid']
product_id = request.GET['product_id']
quantity = request.GET['quantity']
product = Product.objects.get(pk=product_id)
cart = Cart(product=product, userid=uid, quantity=quantity)
cart.save()
return JsonResponse({'message': 'successfully added to cart'})
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('testuser', '*****@*****.**', 'testpassword')
self.client.login(username='******', password='******')
cart_item1 = Cart(title='new item', description='this is a new item', user=self.user, request_type='new feature')
cart_item1.save()
stripe.api_key = settings.STRIPE_SECRET
def create_cart(sender, instance, **kwargs):
"""Creating cart after register"""
from cart.models import Cart
try:
Cart.objects.get(user=instance)
except Cart.DoesNotExist:
cart = Cart(user=instance)
cart.save()
def add_in_cart(request):
product_name = request.POST.get('product')
product_object = Product.objects.get(name=product_name)
print(f'================={type(product_object)}===========')
product = Cart(user=request.user, product=product_object)
product.save()
return redirect('')
def get_cart(session):
try:
cart = Cart.objects.get(pk=session['cart_id'])
except (KeyError, Cart.DoesNotExist) as e:
cart = Cart()
cart.save()
session['cart_id'] = cart.id
return cart
def get(self, request):
#what we need for this page it to enable it to be able to get all data from the carts, so
#all the products, their costs and total cost, main photo of each product, and ability to remove items from the cart
if 'cart_id' in request.session:
self.cart = Cart.get_cart(request.session['cart_id'])
else:
self.cart = Cart.get_cart()
request.session['cart_id'] = self.cart.id
return render(request, 'cart/home.html', {'cart':self.cart})
def create_cart(request): if request.session.session_key is None: request.session.save() cart=Cart(session=request.session.session_key) if request.user.is_authenticated(): cart.user=request.user cart.save() return cart
def get_basket_info(request):
session_key = request.session.session_key
if not session_key:
request.session.cycle_key()
cart = Cart(request)
total_amount = cart.get_sum()
products_total_count = len(cart)
products_in_basket = cart.cart
return locals()
def update_cart(request, slug):
request.session.set_expiry(120000)
try:
qty = request.GET.get('qty')
update_qty = True
except:
qty = None
update_qty = False
try:
attr = request.GET.get('attr')
except:
attr = None
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
try:
product = Product.objects.get(slug=slug)
except Product.DoesNotExist:
pass
except:
pass
cart_item = CartItem.objects.get_or_create(cart=cart, product=product)
if update_qty and qty:
if int(qty) == 0:
cart_item.delete()
else:
cart_item.quantity=qty
cart_item.save()
else:
pass
'''
if not cart_item in cart.items.all():
cart.items.add(cart_item)
else:
cart.items.remove(cart_item)
'''
new_total = 0.00
for item in cart.cartitem_set.all():
line_total = float(item.product.price) * item.quantity
new_total += line_total
request.session['items_total'] = cart.cartitem_set.count()
cart.total = new_total
cart.save()
return HttpResponseRedirect(reverse("view"))
def CartAdd(request, product_id):
cart = Cart(request)
product = get_object_or_404(Item, 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:CartDetail')
def cart(request):
user = request.user
if user.is_authenticated():
cart = Cart.objects.get(user=user)
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
context = {
'cart': cart,
}
return render_to_response(
'cart/caja.html',
context_instance=RequestContext(request, context))
def registration(request):
args = {}
args.update(csrf(request))
args['form'] = UserCreationForm()
if request.POST:
newuser_form = UserCreationForm(request.POST)
if newuser_form.is_valid():
newuser_form.save()
newuser = auth.authenticate(username=newuser_form.cleaned_data['username'],
password=newuser_form.cleaned_data['password2'])
auth.login(request, newuser)
request.session['visit'] = True
cart = Cart()
cart.owner = newuser
cart.save()
return redirect('/')
else:
args['form'] = newuser_form
return render_to_response('registration.html', args)
def add_to_cart(request, id):
user = request.user
product = Product.objects.get(id=id)
carts = Cart.objects.all()
if user.is_authenticated():
if not Cart.objects.filter(user=user, product=product, status=1).exists():
cart = Cart(user=user, product=product, status=1)
cart.save()
error = "This item is successfully added to the cart"
data = {"error": error}
return HttpResponse(json.dumps(data), content_type="application/json")
else:
error = "This item is already in the cart"
flag = 1
else:
error = "you need to log in first"
flag = 1
data = {"flag": flag, "error": error}
return HttpResponse(json.dumps(data), content_type="application/json")
def add_subscribe_again_to_cart(request, recipient_id):
request.session.set_expiry(3000)
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
if request.method == "POST":
#qty = request.POST['qty']
print "we got post add to cart"
try:
print "we got post and add subscribe again to card"
subscription = Subscription.objects.filter(is_active=1).filter(type=1).first()
print subscription
flug = subscription.slug
recipient = Recipient.objects.get(id=recipient_id)
print flug
print recipient
cart_item = CartItem.objects.create(cart=cart, subscription=subscription, flug=flug, recipient=recipient)
cart_item.line_total = subscription.price
print "line total is %s " % cart_item.line_total
cart_item.save()
except:
pass
else:
pass
calc_cart_shipping_total(cart.id)
calc_cart_total(request, cart.id)
# success message
request.session['items_total'] = cart.cartitem_set.count()
return HttpResponseRedirect(reverse("view_cart"))
def post(self, request):
cart = Cart()
cart.save()
item = Item()
item.cart = cart
item.quantity = int(request.POST.get("quantity", 1))
item.product_id = int(request.POST["product_id"])
item.save()
order = Order()
order.cart_id = cart.id
order.address = "Уточнить у клиента"
order.phone = request.POST.get('phone')
order.name = request.POST.get('name')
order.comment = "Заказ в один клик"
if request.user.is_authenticated():
order.customer = request.user
order.save()
cart_service = CartService(request, cart)
params = {
"phone": unicode(request.POST["phone"]),
"name": unicode(request.POST["name"]),
"customer": request.user,
"comment": order.comment,
"orderno": order.id,
"orderdt": order.checkout_date,
"orderaddr": order.address,
"ordercart": cart_service,
}
send_notification("order_notice", params)
response = HttpResponse(json.dumps({"order_id": order.id, "ok": 1}),
content_type="application/json")
return response
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/")
def get_current_cart(request):
"""creates a new cart or retrieves the current one"""
cart_id = request.session.get(CART_ID_SESSION_KEY, '')
if cart_id == '':
cart = Cart()
cart._cart_id(request)
else:
carts = Cart.objects.filter(cart_id=cart_id)
if carts.count() <= 0:
cart = Cart()
cart.cart_id = cart_id
cart.save()
else:
cart = carts[0]
return cart
def get_cart_by_session(request):
cart =''
if 'admin' not in request.get_full_path().split('/'):
if request.session.get('cart'):
try:
cart = Cart.objects.get(id = request.session.get("cart"))
except:
cart = Cart()
cart.session = '1024'
cart.save()
request.session['cart'] = cart.id
else:
cart = Cart()
cart.session = '1024'
cart.save()
request.session['cart'] = cart.id
else:
pass
return {'cart':cart}
def add(request, slug):
product = Products.objects.get(slug=slug)
try:
active = request.session['cart']
except:
request.session['cart'] = 'empty'
if request.session['cart'] == 'empty':
mycart = Cart()
mycart.save()
mycart.products.add(product)
request.session['cart'] = mycart.id
request.session['total_items'] = len(mycart.products.all())
else:
cart_id = request.session['cart']
mycart = Cart.objects.get(id=cart_id)
mycart.products.add(product)
mycart.active = True
mycart.save()
request.session['total_items'] = len(mycart.products.all())
return HttpResponseRedirect('/products/%s' %(slug))
def display_menu(request, entry_id=False):
context = RequestContext(request)
user = request.user
if entry_id == False:
return HttpResponse("You must first select a delivery window.")
profile = users.views.return_associated_profile_type(user)
entry = Entry.objects.get(id=entry_id)
user_cart = cart_exists(user, entry)
if user_cart == False:
new_cart = Cart(profile=profile,
entry=entry,
total=0)
new_cart.save()
user_cart = new_cart
if not user_cart.is_active():
return user_cart_no_longer_active(request)
item_urls = {}
for item in user_cart.get_cart_items():
item_urls[item.id] = get_url_for_item(item.item)
item_names = []
cart_more_than_one = False
if len(user_cart.get_items()) > 0:
cart_more_than_one = True
cart_id = user_cart.id
total = user_cart.view_order_total_in_usd()
total_price = user_cart.get_total_price_of_cart()
all_items = Item.objects.all()
green_num_ordered = Item.objects.get(name="Green").number_ordered
red_num_ordered = Item.objects.get(name="Red").number_ordered
almond_num_ordered = Item.objects.get(name="Almond").number_ordered
grapefruit_num_ordered = Item.objects.get(name="Grapefruit").number_ordered
return render_to_response(
'menu.html',
{
'all_items':all_items,
'entry':entry,
'entry_id':entry_id,
'user':user,
'profile':profile,
'cart_id':cart_id,
'cart_more_than_one':cart_more_than_one,
'item_urls':item_urls,
'total':total,
'total_price':total_price,
'green_num_ordered':green_num_ordered,
'red_num_ordered':red_num_ordered,
'almond_num_ordered':almond_num_ordered,
'grapefruit_num_ordered':grapefruit_num_ordered,
},
context)
def add_to_cart(request, slug):
request.session.set_expiry(3000)
try:
the_id = request.session['cart_id']
except:
new_cart = Cart()
new_cart.save()
request.session['cart_id'] = new_cart.id
the_id = new_cart.id
cart = Cart.objects.get(id=the_id)
if request.method == "POST":
#qty = request.POST['qty']
print "we got post add to cart"
try:
print "we got post and add subscription"
subscription = Subscription.objects.get(slug=slug)
cart_item = CartItem.objects.create(cart=cart, subscription=subscription, flug=slug)
cart_item.line_total = subscription.price
print "line total is %s " % cart_item.line_total
cart_item.save()
except Subscription.DoesNotExist:
print "no sub exists, so this is a single issue"
issue = Issue.objects.get(slug=slug)
#cart_item = CartItem.objects.create(cart=cart, single=issue, flug=slug)
cart_item, created = CartItem.objects.get_or_create(cart=cart, single=issue, flug=slug)
if created:
print "single issue cart item created"
qty = 1
cart_item.quantity = qty
cart_item.line_total = issue.price
cart_item.save()
print "line total is %s " % cart_item.line_total
else:
print "single issue cart item found"
qty = cart_item.quantity
print qty
new_qty = qty + 1
cart_item.quantity = new_qty
print cart_item.quantity
cart_item.line_total = issue.price * new_qty
cart_item.save()
print "line total is %s " % cart_item.line_total
except:
print "other"
# error message
return HttpResponseRedirect(reverse("view_cart"))
calc_cart_shipping_total(cart.id)
calc_cart_total(request, cart.id)
# success message
request.session['items_total'] = cart.cartitem_set.count()
return HttpResponseRedirect(reverse("view_cart"))
return HttpResponseRedirect(reverse("view_cart"))
def create_cart(sender, **kw):
user = kw['instance']
if kw['created']:
cart = Cart(user=user)
cart.save()
def add_to_cart(request,product_id,quantity):
product=Product.objects.get(id=product_id)
cart=Cart(request)
cart.add(product,product.unit_price,quantity)
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'])
def remove_from_cart(request,product_id):
product = Product.objects.get(id=product_id)
cart = Cart(request)
cart.remove(product)
