def __init__(self, request):
if request.user.is_authenticated and 'cart_id' in request.session:
# this means session of anon has a cart but now he logged in, so the cart should connect to the user, and if there is an old active cart for this user deactivate it
try:
cart = Cart.objects.get(user= request.user, active=True)
cart.active = False
cart.save()
self.cart = Cart.objects.get(id = request.session['cart_id'], active=True)
self.cart.user = request.user
self.cart.save()
request.session.pop('cart_id')
except:
self.cart = Cart.objects.get(id = request.session['cart_id'], active=True)
self.cart.user = request.user
self.cart.save()
request.session.pop('cart_id')
elif request.user.is_authenticated:
try:
self.cart = Cart.objects.get(user= request.user, active=True)
except:
self.cart = Cart(user = request.user)
self.cart.save()
elif 'cart_id' in request.session:
try:
self.cart = Cart.objects.get(id = request.session['cart_id'], active=True)
except:
request.session.pop('cart_id')
self.cart = Cart()
self.cart.save()
request.session['cart_id'] = self.cart.id
else:
self.cart = Cart()
self.cart.save()
request.session['cart_id'] = self.cart.id
self.load_items()
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 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 get(self, request):
try:
cart_id = self.request.session['cart_id']
cart = Cart.objects.get(id=cart_id)
self.request.session['total'] = cart.items.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
self.request.session['cart_id'] = cart_id
cart = Cart.objects.get(id=cart_id)
qty = request.GET['qty']
item_id = request.GET['item_id']
cart_item = CartItem.objects.get(id=int(item_id))
cart_item.quantity = int(qty)
cart_item.item_total = int(qty) * Decimal(cart_item.book.price)
cart_item.save()
new_cart_total = 0.00
for item in cart.items.all():
new_cart_total += float(item.item_total)
cart.cart_total = new_cart_total
cart.save()
return JsonResponse({
'cart_total': cart.items.count(),
'item_total': cart_item.item_total,
'cart_total_price': cart.cart_total
})
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_carts(u_id, g_id, num):
goods = Goods.objects.filter(g_id=g_id)
good = goods.first()
carts = Cart.objects.filter(u_id=u_id, g_id=g_id)
if carts:
cart = carts.first()
cart.c_num += int(num)
cart.c_total_price += int(num) * good.g_price
cart.save()
else:
cart = Cart()
cart.u_id = u_id
cart.g_id = g_id
cart.c_num = int(num)
cart.c_total_price = int(num) * good.g_price
cart.save()
good.g_stock -= int(num)
good.g_sale += int(num)
good.save()
return {
'good': {
'num': cart.c_num,
'uid': u_id,
'gid': g_id,
'total_price': cart.c_total_price
}
}
def get(self, request):
# --------------------------------------------------
# Cart
cart = Cart(request)
# --------------------------------------------------
# Products
objList = Product.objects.featured()
# --------------------------------------------------
# Category count
productCount = dict()
productCount["all"] = Product.objects.all().count()
productCount["macrame"] = Product.objects.macrame().count()
productCount["metal"] = Product.objects.metal().count()
context = {
"webpage_name": self.webpage_name,
"webpage_description": self.webpage_description,
"objList": objList,
"cart": cart,
"productCount": productCount
}
return render(request, self.template_name, context)
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 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 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 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 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 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 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 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 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 change_item_qty(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)
qty = request.GET.get('qty')
item_id = request.GET.get('item_id')
cart_item = CartItem.objects.get(id=int(item_id))
cart_item.qty = int(qty)
cart_item.item_total = int(qty) * Decimal(
cart_item.product.price
) # динамическое прибавление стоимости товаров (без перезагр. стр.)
cart_item.save()
new_cart_total = 0.00 # итоговая сумма товаров
for item in cart.items.all():
new_cart_total += float(item.item_total)
cart.cart_total = new_cart_total
cart.save()
return JsonResponse({
'cart_total': cart.items.count(),
'item_total': cart_item.item_total,
'cart_total_price': cart.cart_total
}) # итоговая сумма товаров
def buy_product(request):
user = request.user
cart = Cart(request)
"""Если в корзине есть товары, то приобретаем их"""
if cart.item_count() != 0:
"""Создание заказа"""
Order.objects.create(customer=user.username)
order = Order.objects.filter(customer=user.profile).latest('created')
"""У покупателя списываются средства со счета"""
sum_buy = float(user.profile.account) - cart.get_total_price()
Profile.objects.filter(user_id=user.id).update(account=sum_buy)
for item in cart:
"""Определение суммы товара, продоваемого продукта, продавца"""
sum_one_product = float(item['price']) * float(item['quantity'])
product_sold = Product.objects.get(name=item['product'])
seller = Profile.objects.get(id=product_sold.owner.id)
"""Зачисление средств на счет продавца"""
old_account = seller.account
new_account = float(old_account) + float(sum_one_product)
Profile.objects.filter(id=seller.id).update(account=new_account)
"""Создание единицы заказанного товара из корзины"""
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'],
)
cart.clear()
return render(request, 'thanks.html', {'order': order})
else:
return redirect('/')
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 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 register_user(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
user_profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and user_profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = user_profile_form.save(commit=False)
profile.user = user
profile.save()
cart = Cart()
cart.user = user
cart.t_amount = 0
cart.save()
return redirect('/login')
else:
print(user_form.errors, user_profile_form.errors)
return HttpResponse('Forms Not Valid')
else:
user_form = UserForm()
user_profile_form = UserProfileForm()
context = {
'user_form': user_form,
'user_profile_form': user_profile_form
}
return render(request, 'register.html', context)
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 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 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 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 cart(request):
print(request.user)
if request.method == 'POST':
if request.POST.get('sub') == 'Add To cart':
pid = request.POST.get('pid')
product = Products.objects.get(pk=pid)
qty = request.POST.get('qty')
price = request.POST.get('amount')
amount = float(qty) * float(price)
print(product, qty, amount)
item = Cart(user=request.user,
product=product,
product_qty=qty,
product_amount=amount)
item.save()
if request.POST.get('sub') == 'Delete':
item_id = request.POST.get('item_id')
item = Cart.objects.get(pk=item_id)
print(item_id, item)
item.delete()
cart = Cart.objects.filter(user=request.user)
print(cart)
context = {'cart': cart}
return render(request, 'cart/cart.html', context)
def get(self, request):
try:
cart_id = self.request.session['cart_id']
cart = Cart.objects.get(id=cart_id)
self.request.session['total'] = cart.items.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
self.request.session['cart_id'] = cart_id
cart = Cart.objects.get(id=cart_id)
book = Book.objects.get(id=request.GET['book_id'])
cart.add_to_cart(book)
new_cart_total = 0.00
for item in cart.items.all():
new_cart_total += float(item.item_total)
cart.cart_total = new_cart_total
cart.save()
# return redirect(reverse('book', kwargs={'slug': book.slug}))
return JsonResponse({
'cart_total': cart.items.count(),
'cart_total_price': cart.cart_total
})
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 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 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')
