def show_product(request, slug):
template = 'shop/product.html'
all_category = Category.objects.all()
all_subcategory = SubCategory.objects.all()
all_entries = Product.objects.filter(slug=slug)
for each in all_entries:
model_product = each.id
all_reviews = Review.objects.filter(product=model_product)
if request.method == 'POST' and request.user.is_authenticated:
product = get_object_or_404(Product, slug=slug)
acc = User.objects.get(email=request.user.email)
if Cart.objects.all().filter(user=acc, product=product).exists():
cart = Cart.objects.get(user=acc, product=product)
Cart.objects.all().filter(
user=acc, product=product).update(pr_count=cart.pr_count + 1)
else:
new_cart = Cart(user=acc, product=product, pr_count=1)
new_cart.save()
return render(request,
template,
context={
'product': all_entries,
'reviews': all_reviews,
'categorys': all_category,
'subcategorys': all_subcategory
})
def add_to_cart(request):
user = request.user
itemID = int(request.POST.get('itemID', 0))
quantity = int(request.POST.get('qnty', 0))
request.session['view'] = 'shop';
try:
item = Shop.objects.get(id=itemID)
except:
item = None
cart = []
try:
#if len(Cart.objects.all()) > 0:
cart = Cart.objects.get(item_id=itemID,user_id=user)
cart.qnty=cart.qnty+quantity
except Cart.DoesNotExist:
cart = None
cart = Cart(user_id=user, item_id=item, qnty=quantity)
cart.save()
response_data = {}
try:
response_data['result'] = 'Ok'
except:
response_data['result'] = 'not ok'
return HttpResponse(json.dumps(response_data), content_type="application/json")
def add_to_cart(request):
userID = request.user.id
itemID = int(request.POST.get('itemID', 0))
quantity = int(request.POST.get('qnty', 0))
request.session['view'] = 'shop'
try:
item = Shop.objects.get(id=itemID)
except:
item = None
cart = []
try:
#if len(Cart.objects.all()) > 0:
cart = Cart.objects.get(item_id=itemID)
except Cart.DoesNotExist:
cart = None
if not cart:
cart = Cart(user_id=userID,
item_id=itemID,
qnty=quantity,
total_price=item.price)
else:
cart.qnty = cart.qnty + quantity
cart.save()
response_data = {}
try:
response_data['result'] = 'Ok'
except:
response_data['result'] = 'not ok'
return HttpResponse(json.dumps(response_data),
content_type="application/json")
def add_to_cart(for_cart, user):
''' Добавляет позиции корзины неавторизованного пользователя к корзине авторизованного.
Вызывается при входе пользователя, либо его регистрации
'''
for position in for_cart:
owner_ = get_object_or_404(Client, user__username=user.username)
# quantity_ = int(form.cleaned_data['quantity'])
product_ = get_object_or_404(Product, id=position.product.id)
# cartElement_ = CartElement.objects.create(product=product_, quantity=quantity_, is_preorder=False)
cart_ = Cart.objects.filter(owner__user__username=user.username,
status=True)
if not cart_:
cart_ = Cart(owner=owner_, datetime=datetime.datetime.now())
cart_.save()
else:
for item in cart_:
if item.status:
cart_ = item
break # Пока берем первую запись не являющуюся заказом
# Провярzем на наличие позиции в корзине у этого пользователя
cartElement_ = CartElement.objects.filter(product=product_,
cart__id=cart_.id)
# print('found', cartElement_)
if not cartElement_:
cartElement_ = position
cart_.cartElement.add(cartElement_)
cart_.save()
else:
# Ориентируемся что пока у пользователя только одна текущая корзина
cartElement_[
0].quantity = cartElement_[0].quantity + position.quantity
cartElement_[0].save()
def post(self, request):
if request.POST.get('email'):
name = request.POST.get('name')
phone = request.POST.get('phone')
email = request.POST.get('email')
customer = Customer(name=name, phone=phone, email=email)
customer.save()
qrcode_path = customer.qrcode_create()
customer.qrcode = qrcode_path
customer.save()
order = Order(customer=customer, )
order.save()
cart = request.session.get('cart')
if cart:
for product_id, quantity in cart.items():
cart = Cart(product_id=product_id,
quantity=quantity,
order=order,
complete=True)
cart.save()
del request.session['cart']
request.session.save()
cart = order.cart_set.all()
context = {'cart': cart, 'order': order}
return render(request, 'shop/order.html', context)
def add_to_cart(request, pk):
# Get current user and product
current_user = request.user
product = Product.objects.get(pk=pk)
# Look if user has existing cart
cart_count = Cart.objects.filter(user=current_user).count()
if cart_count is 0:
# Create new cart
cart = Cart(user=current_user)
cart.save()
else:
# Use existing cart for user
cart = Cart.objects.get(user=current_user)
# Create snapshot and add to user basket
article, created = CartItem.objects.get_or_create(product=product,
user_cart=cart)
article.price_snapshot = product.price
if request.POST.get("quantity").isdigit():
article.quantity = request.POST.get("quantity", "1")
else:
article.quantity = 1
article.save()
messages.info(request, "{} has been added to cart.".format(product.name))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def register_user(request):
user = request.user
if not user.is_anonymous:
return redirect('login:home')
warning = ""
Userform = RegisterForm(request.POST or None)
if request.method == "POST":
if Userform.is_valid(
): #i am using Javascript to check for confirm password and password matching
try:
User.objects.get(email__iexact=form.cleaned_data['email'])
warning = "User with following email exists"
except Exception as e:
ob = Userform.save()
cart = Cart()
cart.user = ob
cart.save()
otp = Otp()
otp.user = ob
otp.save()
log_in(request, ob)
return redirect('login:verify_user')
return render(request, "login/register.html", {
'form1': Userform,
'warning': warning
})
def category_view(request, category_slug):
'''Single category pages'''
category = Category.objects.get(slug=category_slug)
product_of_category = Product.objects.filter(category=category)
products = Product.objects.all()
categories = Category.objects.filter(priority=True)
categories_all = Category.objects.all()
category_title = Category.objects.get(slug=category_slug)
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)
context = {
'product_of_category': product_of_category,
'categories_all': categories_all,
'categories': categories,
'products': products,
'cart': cart,
'category_title': category_title,
}
context = {**context, **context_1}
return render(request, 'category.html', context=context)
def addtocart_prodpage(request):
token = request.session.get("token")
dict = {}
try:
user = User.objects.get(token = token)
prod_id = request.GET.get("prod_id")
product = Product.objects.get(prod_id=prod_id)
prod_num = int(request.GET.get("prod_num"))
# print(prod_num)
cart = Cart.objects.get(user=user,product=product,is_delete=False)
try:
cart.prod_num = cart.prod_num + prod_num
if cart.prod_num <= product.prod_num :
cart.save()
else:
raise Exception
dict["status"] = "success"
except Exception as e:
print(e)
dict["status"] = "error"
except User.DoesNotExist :
dict["status"] = "nologin"
except Cart.MultipleObjectsReturned as e:
dict["status"] = "error"
except Cart.DoesNotExist as e:
if prod_num<=product.prod_num:
cart = Cart(user=user, product=product, prod_num=prod_num)
cart.save()
dict["status"] = "success"
else:
dict["status"] = "error"
return JsonResponse(dict)
def buynow(request, prid):
current_user = request.user
Cart.objects.filter(user_id=current_user.id).delete()
data = Cart()
data.user_id = current_user.id
data.product_id = prid
data.qty = 1
data.save()
return HttpResponseRedirect('/cart')
def addtocart(request,id):
r=Product.objects.get(id=id)
if request.method == 'POST':
p=Cart(user_id=request.user.id,product_id=id)
p.save()
return redirect('main')
return render(request,'shop/tb.html',{'data':r})
def add_product_to_cart(user, product=None, count=1):
for item in range(0, count):
cart = Cart()
if product is not None:
cart.product = product
else:
cart.product = add_random_product()
cart.created_by = user
cart.save()
def check_cart(request):
cart_id = request.session.get('cart_id')
if cart_id is not None:
cart = Cart.objects.get(id=cart_id)
request.session['total'] = cart.item.count()
else:
cart = Cart()
cart.save()
request.session['cart_id'] = cart.id
return cart
def cart_insert(request):
# 세션변수 userid 확인, 없으면 빈문자열이 리턴됨
uid = request.session.get("userid", "")
if uid != "": # 로그인한 상태
vo = Cart(userid = uid,
product_id = request.POST["product_id"],
amount = request.POST["amount"])
vo.save() # 장바구니 테이블에 추가
return redirect("/cart_list") # 장바구니 목록으로 이동
else: # 로그인하지 않은 상태
return redirect("/login") # 로그인 페이지로 이동
def get_logged_user_cart(user):
"""
Get active cart of the user
If he don't have one then a new cart is created.
"""
carts = Cart.objects.filter(user__id=user.id, active=True)
if len(carts) == 0:
cart = Cart(user=user, active=True)
cart.save()
else:
cart = carts[0]
return cart
def Add_To_Cart(request, id):
product = Product.objects.all()
item = Product.objects.get(pk=id)
print(item)
if not (Cart.objects.filter(product_id=item.id).exists()):
cart = Cart(product_id=item.id)
else:
cart = Cart.objects.get(product_id=item.id)
cart.amount += 1
cart.save()
#print(cart)
return redirect(to='index')
def make_order_view(request):
'''Page order'''
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)
form = OrderForm(request.POST or None)
images = ThemeFront.objects.all()
categories = Category.objects.filter(priority=True)
context = {
'cart': cart,
'images': images,
'categories': categories,
}
context = {**context, **context_1}
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']
sail = form.cleaned_data['sail']
date_delivery = form.cleaned_data['date_delivery']
address_true = form.cleaned_data['address_true']
comment = form.cleaned_data['comment']
new_order = Order()
new_order.user = request.user
new_order.save()
new_order.items.add(cart)
new_order.first_name = name
new_order.last_name = last_name
new_order.phone = phone
new_order.buying_type = buying_type
new_order.sail = sail
new_order.date_delivery = date_delivery
new_order.address = address_true
new_order.comment = comment
new_order.total = cart.cart_total
new_order.save()
del request.session['cart_id']
del request.session['total']
return HttpResponseRedirect(reverse('thank_you'))
return render(request, 'thank_you.html', context=context)
def add_cart_to_database(user, size, tshirt):
size = SizeVariant.objects.get(size=size, tshirt=tshirt)
existing = Cart.objects.filter(user=user, sizeVariant=size)
if len(existing) > 0:
obj = existing[0]
obj.quantity = obj.quantity + 1
obj.save()
else:
c = Cart()
c.user = user
c.sizeVariant = size
c.quantity = 1
c.save()
def product_view(request, product_slug):
try:
cart_id = request.session['cart_id']
cart = Cart.object.get(id=cart_id)
request.session['total'] = CartItem.object.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.object.get(id=cart_id)
product = Product.object.get(slug=product_slug)
context = {
'product': product,
'cart': cart,
}
return render(request, 'product.html', context)
def cart_update(request):
uid = request.session.get("userid", "") # 세션변수
if uid != "": # 세션값이 있으면(로그인한 상태)
# 폼 데이터가 배열값인 경우 getlist("배열이름")
amt = request.POST.getlist("amount")
cid = request.POST.getlist("cart_id")
pid = request.POST.getlist("product_id")
for idx in range(len(cid)):
vo = Cart(cart_id = cid[idx],
userid = uid,
product_id = pid[idx],
amount = amt[idx])
vo.save() # 저장
return redirect("/cart_list") # 장바구니 목록으로 이동
else: # 세션이 없으면(로그인하지 않은 경우)
return redirect("/login") # 로그인 페이지로 이동
def post(self , request):
add = request.session.get('plusItem')
form = CustomerAuthForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
if user:
loginuser(request, user)
session_cart = request.session.get('cart')
if session_cart is None:
session_cart = []
else:
for c in session_cart:
size = c.get('size')
tshirt_id = c.get('tshirt')
quantity = c.get('quantity')+1
cart_obj = Cart()
cart_obj.sizeVariant = SizeVariant.objects.get(
size=size, tshirt=tshirt_id)
cart_obj.quantity = quantity
cart_obj.user = user
cart_obj.save()
# { size , tshirt , quantiti }
cart = Cart.objects.filter(user=user)
session_cart = []
for c in cart:
obj = {
'size': c.sizeVariant.size,
'tshirt': c.sizeVariant.tshirt.id,
'quantity': c.quantity
}
session_cart.append(obj)
request.session['cart'] = session_cart
next_page = request.session.get('next_page')
if next_page is None:
next_page = 'homepage'
return redirect(next_page)
else:
return render(request,
template_name='login.html',
context={'form': form})
def checkout_view(request):
try:
cart_id = request.session['cart_id']
cart = Cart.object.get(id=cart_id)
request.session['total'] = CartItem.object.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.object.get(id=cart_id)
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
form = OrderForms(request.POST or None)
if form.is_valid():
first_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']
print(buying_type)
new_order = Order.object.create(
user = request.user,
items = cart,
total = cart.cart_total,
first_name = first_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('thanks'))
context = {
'cart': cart,
'cart_total':CartItem.object.count(),
'form': form
}
return render(request, 'checkout.html', context)
def checkout_view(request):
'''Page pre order'''
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.filter(priority=True)
context = {
'cart': cart,
'categories': categories,
}
context = {**context, **context_1}
return render(request, 'checkout.html', context=context)
def base_view(request):
try:
cart_id = request.session['cart_id']
cart = Cart.object.get(id=cart_id)
request.session['total'] = CartItem.object.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.object.get(id=cart_id)
categories = Category.object.all()
products = Product.object.all()
context = {
'categories': categories,
'products': products,
'cart': cart,
}
return render(request, 'main.html', context)
def products(request, slug):
template = 'shop/products_new.html'
all_category = Category.objects.all()
all_subcategory = SubCategory.objects.all()
click_subcategory = SubCategory.objects.filter(slug=slug)
for each in click_subcategory:
product_name = each.id
current_subcategory = each.name
click_product = Product.objects.filter(subcategory=product_name)
paginator = Paginator(Product.objects.all(), 2)
current_page = request.GET.get('page', 1)
articles = paginator.get_page(current_page)
prev_page_number = next_page_number = 0
if articles.has_previous():
prev_page_number = int(current_page) - 1
if articles.has_next():
next_page_number = int(current_page) + 1
prev_page_url = urllib.parse.urlencode({'page': prev_page_number})
next_page_url = urllib.parse.urlencode({'page': next_page_number})
prev_page_url = slug + '?' + str(prev_page_url)
next_page_url = slug + '?' + str(next_page_url)
if request.method == 'POST' and request.user.is_authenticated:
product = get_object_or_404(Product, slug=slug)
acc = User.objects.get(email=request.user.email)
if Cart.objects.all().filter(user=acc, product=product).exists():
cart = Cart.objects.get(user=acc, product=product)
Cart.objects.all().filter(
user=acc, product=product).update(pr_count=cart.pr_count + 1)
else:
new_cart = Cart(user=acc, product=product, pr_count=1)
new_cart.save()
return render(request,
template,
context={
'products': click_product,
'categorys': all_category,
'subcategorys': all_subcategory,
'current': current_subcategory,
'current_page': current_page,
'prev_page_url': prev_page_url,
'next_page_url': next_page_url,
})
def add_product(update: Update, context: CallbackContext):
query = update.callback_query
query.answer()
chat_id = query.from_user.id
username = query.from_user.username
product_callback_raw = update.callback_query.message.caption
product_callback_split = product_callback_raw.split("\n")
p = Product.objects.filter(
name=product_callback_split[0]).values_list("pk")
product_callback_id = str(p[0]).replace('(',
'').replace(')',
'').replace(',', '')
c, created = Customer.objects.get_or_create(telegram_id=chat_id,
defaults={
'name':
query.from_user.username,
})
user = Customer.objects.filter(name=username).values_list("pk")
user_ = str(user[0]).replace('(', '').replace(')', '').replace(',', '')
cart_ = Cart.objects.filter(
customer_id=user_,
product_id=product_callback_id).values_list("quantity")
if cart_:
quantity_ = Cart.objects.filter(
customer_id=user_,
product_id=product_callback_id).values_list("quantity")
new_quantity = str(quantity_[0]).replace('(', '').replace(')',
'').replace(
',', '')
update_cart = int(new_quantity) + 1
c = Cart.objects.get(customer_id=user_, product_id=product_callback_id)
c.quantity = update_cart
c.save()
context.bot.send_message(chat_id=update.effective_chat.id,
text=f" +1 {product_callback_split[0]}\n")
else:
c = Cart(customer_id=user_, product_id=product_callback_id, quantity=1)
c.save()
context.bot.send_message(
chat_id=update.effective_chat.id,
text=
f"<b>{username}</b> {product_callback_split[0]} added to your cart",
parse_mode=telegram.ParseMode.HTML)
def add_to_cart_view(request):
try:
cart_id = request.session['cart_id']
cart = Cart.object.get(id=cart_id)
request.session['total'] = CartItem.object.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.object.get(id=cart_id)
product_slug = request.GET.get('product_slug')
product = Product.object.get(slug=product_slug)
cart.add_to_cart(product.slug)
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':CartItem.object.count(), 'cart_total_price': cart.cart_total,})
def change_item_qty(request):
try:
cart_id = request.session['cart_id']
cart = Cart.object.get(id=cart_id)
request.session['total'] = CartItem.object.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.object.get(id=cart_id)
qty = request.GET.get('qty')
item_id = request.GET.get('item_id')
cart.change_qty(qty, item_id)
cart_item = CartItem.object.get(id=int(item_id))
return JsonResponse({
'cart_total':CartItem.object.count(),
'item_total': cart_item.item_total,
'cart_total_price': cart.cart_total,
})
def get_cart(self):
if self.request.user.is_authenticated:
user_id = self.request.user.id
try:
cart = Cart.objects.get(user_id=user_id)
except ObjectDoesNotExist:
cart = Cart(user_id=user_id,
total_cost=0)
cart.save()
else:
session_key = self.request.session.session_key
if not session_key:
self.request.session.save()
session_key = self.request.session.session_key
try:
cart = Cart.objects.get(session_key=session_key)
except ObjectDoesNotExist:
cart = Cart(session_key=session_key,
total_cost=0)
cart.save()
return cart
def count_item_qty(request):
'''Sum total and price on cart'''
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.count_qty(qty, item_id)
return JsonResponse({
'cart_total': cart.items.count(),
'item_total_final': cart_item.item_total,
'cart_total_final': cart.cart_total,
})
def order_create_view(request):
'''Registration order'''
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)
form = OrderForm(request.POST or None)
categories = Category.objects.filter(priority=True)
context = {
'form': form,
'cart': cart,
'categories': categories,
}
context = {**context, **context_1}
return render(request, 'order.html', context=context)
def not_login(request, next_='/'):
form_ = NotLoginForm()
for_cat_menu = Category.objects.all()
if ('next' in request.GET) and request.GET['next'].strip():
next_ = request.GET['next']
if not request.user.is_authenticated():
request.session.set_expiry(None)
if 'key' not in request.session:
request.session['last_date'] = str(datetime.datetime.now())
request.session.save()
request.session['key'] = request.session.session_key
for_cart = CartElement.objects.filter(cart__key=request.session['key'], cart__status=True)
else:
return HttpResponseRedirect(reverse_lazy('cart'))
l = len(for_cart)
if request.method == 'POST':
form_ = NotLoginForm(request.POST)
if form_.is_valid():
# print('Save order')
p = form_.save_person()
# print(p)
owner_ = get_object_or_404(Client, user__username='******')
cart_ = Cart.objects.filter(owner__user__username='******', key=request.session['key'], status=True)
comment = form_.cleaned_data['comment']
if not cart_:
cart_ = Cart(owner=owner_, datetime=datetime.datetime.now(), key=request.session['key'])
cart_.save()
else:
for item in cart_:
if item.status:
cart_ = item
break # Пока берем первую запись не являющуюся заказом
new_order = Order(list=cart_, datetime=datetime.datetime.now(), status='NEW', comment=comment, person=p)
new_order.save()
cart_.status = False
cart_.summ = summ_in_cart(for_cart)
cart_.save()
# print(" Sending mail")
for_order = CartElement.objects.filter(cart__id=new_order.list.id)
# user = request.user
to = [p.email]
from_email = settings.DEFAULT_FROM_EMAIL
subject_ = 'Новый заказ - ' + str(new_order.id)
text_content = render_to_string('bshop/email/neworder.txt',
{'first_name': p.first_name,
'summ_in_cart': summ_in_cart(for_cart),
'order': new_order,
'positions': for_order})
html_content = render_to_string('bshop/email/neworder.html',
{'first_name': p.first_name,
'summ_in_cart': summ_in_cart(for_cart),
'order': new_order,
'positions': for_order})
# print(to, from_email, subject_, html_content)
send_email(to, from_email, subject_, text_content, html_content)
to = [settings.ADMIN_EMAIL]
send_email(to, from_email, subject_, text_content, html_content)
return HttpResponseRedirect(reverse_lazy('orders'))
template = loader.get_template('bshop/notlogin.html')
context = {'menu': for_cat_menu, 'path': request.path, 'user': request.user, 'session': request.session,
'cart_length':l, 'summ_in_cart': summ_in_cart(for_cart), 'next': next_, 'form': form_}
return HttpResponse(template.render(context, request))
