def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
# 如果session中有优惠码，就修改order模型中的优惠码、折扣字段再保存
if cart.coupon:
order.coupon = cart.coupon
order.discount = cart.coupon.discount
order.save()
r = Recommender()
r.products_bought([item['product'] for item in cart])
# 这里还是按原价算
for item in cart:
OrderItem.objects.create(order=order, product=item['product'], price=item['price'], quantity=item['quantity'])
# 清空购物车
cart.clear()
# 执行发送邮件通知的异步任务，任务将会被添加进队列中，将会尽快被worker执行
order_created.delay(order.id)
# 在session中保存订单号
request.session['order_id'] = order.id
# 重定向到支付网关
return redirect(reverse('payment:process'))
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {'cart': cart, 'form': form})
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = Order(**form.data)
order.save()
order.paid="1"
for item in cart:
order.products.connect(item["product"], {'quantity':item['quantity']})
order.save()
print(order.products.all())
product_ids = list(cart.cart.keys())
print(product_ids)
products = []
for id in product_ids:
query = f"match (a) where ID(a) = {id} return a"
result, meta = db.cypher_query(query)
products.append(Product.inflate(result[0][0]))
r = Recommender()
r.products_bought([products])
# clear the cart
cart.clear()
return render(request,
'orders/order/created.html',
{'order': order})
else:
form = OrderCreateForm()
return render(request,
'orders/order/create.html',
{'cart': cart, 'form': form})
def place_order(request):
if request.method == 'POST':
form = OrderForm(request.POST)
r = Recommender()
cart = Cart(request)
if form.is_valid():
order = form.save(commit=False)
order.discount = cart.get_discount()
order.coupon = cart.coupon
order.save()
for item in cart:
order.items.create(product=item['product'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
send_order_email.delay(order.id)
r.products_bought([item['product'] for item in cart])
return render(request, 'order/successful_order.html',
{'order_id': order.id})
return render(request, 'order/order_form.html', {'form': OrderForm()})
def cart_detail(request):
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={
'quantity': item['quantity'],
'override': True
})
coupon_apply_form = CouponApplyForm()
r = Recommender()
cart_products = [item['product'] for item in cart]
print(cart_products)
print(type(cart_products))
# prints "[<Product: Afternoon>]"
# prints "[<Product: Afternoon>, <Product: Apple & Elderflower>]"
# type = <class 'list'>
recommended_products = r.suggest_products_for(cart_products, max_results=4)
return render(
request, 'cart/detail.html', {
'cart': cart,
'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_products
})
def order_view(request):
if request.method == 'POST':
order_form = OrderForm(request.POST)
if order_form.is_valid():
cart = Cart(request)
order = order_form.save()
for item in cart:
# Create new order item
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
# Update ranking for products
r.zincrby('product_ranking', item['quantity'],
item['product'].pk)
rec = Recommender()
rec.products_bought(order)
cart.clear()
payment_url = request.build_absolute_uri(
reverse('order:payment', args=[
order.pk,
]))
send_order_created_email.delay(order.pk, order.email, payment_url)
return redirect('order:payment', pk=order.pk)
else:
order_form = OrderForm()
return render(request, 'order/order.html', {'order_form': order_form})
def cart_detail(request):
cart = Cart(request)
product = get_object_or_404(Product, id=1)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={
'quantity': item['quantity'],
'override': True,
})
coupon_apply_form = CouponApllyForm()
r = Recommender()
cart_products = [item['product'] for item in cart]
if cart:
recommended_products = r.suggest_products_for(cart_products,
max_results=4)
else:
product = get_object_or_404(Product, id=1)
cart_products = [product]
recommended_products = r.suggest_products_for(cart_products,
max_results=4)
return render(
request, 'cart/detail.html', {
'cart': cart,
'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_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)
# set the order in the session
request.session["order_id"] = order.id
# add recommendation
recommender = Recommender()
recommender.products_bought(order.items.all())
# redirect for payment
return redirect("payment:process")
else:
form = OrderCreateForm()
return render(request, "orders/order/create.html", {
"cart": cart,
"form": form
})
def cart_detail(request):
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={
'quantity': item['quantity'],
'override': True
})
coupon_apply_form = CouponApplyForm()
try:
r = Recommender()
cart_products = [item['product'] for item in cart]
recommended_products = r.suggest_products_for(cart_products,
max_results=4)
except redis.exceptions.ConnectionError as e:
logger.error(f"Attention {e}")
recommended_products = None
return render(
request, 'cart/detail.html', {
'cart': cart,
'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_products
})
def cart_detail(request):
"""
view for cart details
:param request:
:return:
"""
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={
'quantity': item['quantity'],
'override': True
}
)
coupon_apply_form = CouponApplyForm()
r = Recommender()
# Getting the product from cart items in the cart.
# Each item in the cart has a product
cart_products = [item['product'] for item in cart]
# Passing the products to the recommendation engine
recommended_products = r.suggest_products_for(cart_products, max_results=4)
return render(request,
'cart/detail.html',
{
'cart': cart,
'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_products
})
def cart_detail(request):
cart = Cart(request)
categories = Category.objects.all()
for item in cart:
item["update_quantity_form"] = CartAddSingleProductForm(
initial={
"quantity": item["quantity"],
"override": True
})
coupon_apply_form = CouponApplyForm()
r = Recommender()
if len(cart) != 0:
cart_products = [item["product"] for item in cart]
recommended_products = r.suggest_products_for(cart_products,
max_results=4)
else:
recommended_products = 0
return render(
request,
"cart/detail.html",
{
"categories": categories,
"cart": cart,
"coupon_apply_form": coupon_apply_form,
"recommended_products": recommended_products,
},
)
def cart_remove(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
r = Recommender()
r.set_removed_product_id(product_id)
cart.remove(product)
return redirect('cart:cart_detail')
def order_create(request):
"""
view for creating customer order
:param request:
:return:
"""
cart = Cart(request)
form = OrderCreateForm()
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'])
r = Recommender()
cart_products = [item['product'] for item in cart]
r.products_bought(cart_products)
# clear the cart
cart.clear()
order_created.delay(order.id)
# set the order id in the session
request.session['order_id'] = order.id
# redirect for payment
return redirect(reverse('payment:process'))
return render(request, 'order/create.html', {'cart': cart, 'form': form})
def cart_detail(request):
"""
"""
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={
'quantity': item['quantity'],
'update': True
})
coupon_apply_form = CouponApplyForm()
recmdr = Recommender()
cart_products = [item['product'] for item in cart]
recommended_products = recmdr.suggest_products_for(cart_products,
max_results=4)
return render(
request, 'cart/detail.html', {
'cart': cart,
'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_products
})
def order_create(request):
cart = Cart(request)
r = Recommender()
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'])
r.products_bought([item['product'] for item in cart])
# clear the cart
cart.clear()
# launch asynchronous task
order_created.delay(order.id)
# set the order in the session
request.session['order_id'] = order.id
# redirect for payment
request.session['order_id'] = order.id
# redirect for payment
return redirect(reverse('payment:process'))
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def post(self, *args, **kwargs):
"""
If the payment process successful, we create an index for products with Redis.
Add celery task, which sends email invoice with order information [[tasks.py]].
"""
order = self.get_object()
total_cost = order.get_total_cost()
r = Recommender()
nonce = self.request.POST.get('payment_method_nonce', None)
result = gateway.transaction.sale({
'amount': f'{total_cost:.2f}',
'payment_method_nonce': nonce,
'options': {
'submit_for_settlement': True
}
})
if result.is_success:
order.paid = True
order.braintree_id = result.transaction.id
order.save()
r.products_bought(order.items.all())
payment_completed.apply_async([order.pk])
return redirect('payment:done')
return redirect('payment:canceled')
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save()
products = []
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
# создаем список продуктов чтобы добавить их в Redis для последующей рекомендации
products.append(Product.objects.get(name=item['product']))
# очистить корзину
cart.clear()
# order send mail
queue = django_rq.get_queue('default')
queue.enqueue(order_created, order.id)
# добавляем продукт в базу данных редис
r = Recommender()
r.products_bought(products)
return render(request, 'orders/order/created.html',
{'order': order})
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def payment_process(request):
order_id = request.session.get("order_id")
order = get_object_or_404(Order, id=order_id)
if request.method == "POST":
# retrieve nonce
nonce = request.POST.get("payment_method_nonce", None)
# create and submit transaction
result = braintree.Transaction.sale({
"amount": f"{order.get_total_cost():.2f}",
"payment_method_nonce": nonce,
"options": {
"submit_for_settlement": True
},
})
if result.is_success:
# mark the order as paid
order.paid = True
recommender = Recommender()
recommender.products_bought(order.items.all())
# store the unique transaction id
order.braintree_id = result.transaction.id
order.save()
# create invoice email
subject = f"My Shop - Invoice No. {order.id}"
msg = "Please, find attached the invoice for your recent purchase"
email = EmailMessage(subject, msg, "*****@*****.**",
[order.email])
# generate PDF
html = render_to_string("orders/order/pdf.html", {"order": order})
out = BytesIO()
static_root = settings.STATIC_ROOT
stylesheets = [weasyprint.CSS(f"{static_root}css/pdf.css")]
weasyprint.HTML(string=html).write_pdf(out,
stylesheets=stylesheets)
# attach PDF file
email.attach(f"order_{order.id}.pdf", out.getvalue(),
"application/pdf")
# send email
email.send()
return redirect("payment:done")
else:
return redirect("payment:cancelled")
else:
# generate token
client_token = braintree.ClientToken.generate()
return render(
request,
"payment/process.html",
{
"client_token": client_token,
"order": order
},
)
def order_create(request: HttpRequest):
r = Recommender()
cart_products = []
cart = Cart(request)
if cart.get_total_price() <= 0:
return redirect(reverse('shop:product_list'))
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'])
cart_products.append(item['product'])
r.products_bought(cart_products)
cart.clear()
order_created.delay(order.id)
request.session['order_id'] = order.id
return redirect(reverse('payment:process'))
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def payment_notification(sender, **kwargs):
ipn_obj = sender
if ipn_obj.payment_status == ST_PP_COMPLETED:
# payment was successful
order = get_object_or_404(Order, id=ipn_obj.invoice)
# mark the order as paid
order.paid = True
order.save()
# 支付成功后将产品添加到一起购买的redis中
items = []
for item in order.items.all():
items.append(item.product)
r = Recommender()
r.products_bought(items)
# create invoice e-mail
subject = _('My Shop - Invoice no. {}'.format(order.id))
message = _('Please, find attached the invoice for your recent purchase.')
email = EmailMessage(subject,
message,
'*****@*****.**',
[order.email])
# generate PDF
html = render_to_string('orders/order/pdf.html', {'order': order})
out = BytesIO()
stylesheets = [weasyprint.CSS(settings.STATIC_ROOT + 'css/pdf.css')]
weasyprint.HTML(string=html).write_pdf(out,
stylesheets=stylesheets)
# attach PDF file
email.attach('order_{}.pdf'.format(order.id),
out.getvalue(),
'application/pdf')
# send e-mail
email.send()
def payment_process(request):
order_id = request.session.get('order_id')
order = get_object_or_404(Order,id=order_id)
total_cost = order.get_total_cost()
if request.method == 'GET':
random_id = random.randint(0, 999999)
braintree_id = time.strftime('%Y%m%d%H%M%S') + str(random_id)
return render(request, 'pays/process.html', {'app_id': settings.APP_ID, 'total_cost': total_cost,'braintree_id':braintree_id})
else:
total_cost = request.POST.get('total_cost')
braintree_id = request.POST.get('braintree_id')
alipay = AliPay(
appid=settings.APP_ID,
app_notify_url=None,
app_private_key_string=settings.APP_PRIVATE_KEY,
alipay_public_key_string=settings.APP_PUBLIC_KEY,
sign_type='RSA2',
debug=True
)
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no = braintree_id,
total_amount = total_cost,
subject = str(Order.items.product),
return_url = redirect('payment:done'),
)
order.braintree_id = braintree_id
order.paid = True
order.save()
#更新redis中本次购买的商品分数
r = Recommender()
order_items = [order_item.product for order_item in order.items.all()]
r.products_bought(order_items)
send_order_mail(order)
return redirect("https://openapi.alipaydev.com/gateway.do?" + order_string)
def payment_process(request):
order_id = request.session.get('order_id')
order = get_object_or_404(Order, id=order_id)
if request.method == "POST":
# 获得token
nonce = request.POST.get('payment_method_nonce', None)
# 使用token 创建提交交易
result = braintree.Transaction.sale({
'amount':
'{:2f}'.format(order.get_total_cost()),
'payment_method_nonce':
nonce,
'options': {
'submit_for_settlement': True,
}
})
if result.is_success:
# 更改支付状态
order.paid = True
# 保存id
order.braintree_id = result.transaction.id
order.save()
#更新redis本次购买商品
r = Recommender()
order_items = [
order_item.product for order_item in order.items.all()
]
r.products_bought(order_items)
# 创建代有pdf的发票
subject = 'My shop - Invoice no {}'.format(order_id)
message = 'Please,find attached the invouce for your recent purchase'
email = EmailMessage(subject, message, '*****@*****.**',
[order.email])
# 生成pdf
html = render_to_string('orders/order/pdf.html', {'order': order})
out = BytesIO()
stylesheets = [
weasyprint.CSS(settings.STATIC_ROOT + 'css/pdf.css')
]
weasyprint.HTML(string=html).write_pdf(out,
stylesheets=stylesheets)
# 附加pdf附件
email.attach('order_{}.pdf'.format(order_id), out.getvalue(),
'application/pdf')
# 发送邮件
email.send()
return redirect('payment:done')
else:
return redirect('payment:canceled')
else:
# 生成临时token交给js
client_token = braintree.ClientToken.generate()
return render(request, 'payment/process.html', {
'order': order,
'client_token': client_token
})
def cart_detail(request):
cart = Cart(request)
r = Recommender()
cart_products = [item['product'] for item in cart]
r.products_bought([item['product'] for item in cart])
recommended_products = r.suggest_products_for(cart_products , max_results = 4)
return render(request, 'cart/details.html', {'cart': cart , 'recommended_products': recommended_products})
def payment_process(request):
order_id = request.session['order_id']
order = get_object_or_404(Order, id=order_id)
if request.method == 'POST':
nonce = request.POST.get('payment_method_nonce', None)
result = braintree.Transaction.sale({
'amount':
'{:.2f}'.format(order.get_total_cost()),
'payment_method_nonce':
nonce,
"options": {
"submit_for_settlement": True
}
})
if result.is_success:
order.paid = True
order.braintree_id = result.transaction.id
order.save()
#record products to be bought together
r = Recommender()
products = [item.product for item in order.items.all()]
r.products_bought(products)
#create mail of invoice
subject = "My shop - invoice no. {}".format(order.id)
message = 'Please, find attateched the invoice for your recent purchases.'
email = EmailMessage(subject, message, '*****@*****.**',
[order.email])
html = render_to_string('admin/orders/order/pdf.html',
{'order': order})
stylesheets = [
weasyprint.CSS(settings.STATIC_ROOT + 'css/pdf.css')
]
out = weasyprint.HTML(string=html).write_pdf(
stylesheets=stylesheets)
email.attach('order_{}'.format(order.id), out, 'application/pdf')
email.send()
return redirect('payment:done')
else:
return redirect('payment:canceled')
else:
#client_token=braintree.ClientToken.generate()
gateway = braintree.BraintreeGateway(
braintree.Configuration.instantiate())
client_token = gateway.client_token.generate()
return render(request, 'payment/process.html', {
'order': order,
'client_token': client_token
})
def cart_view(request):
cart = Cart(request)
products = [item['product'] for item in cart]
if products:
r = Recommender()
recommended_products = r.suggest_products_for(products)
else:
recommended_products = None
return render(request, 'cart/cart.html',
{'recommended_products': recommended_products})
def product_detail(request, product_id, slug):
product = get_object_or_404(Product, id=product_id, slug=slug, available=True)
cart_product_form = CartAddProductForm()
r = Recommender()
recommended_products = r.suggest_products_for([product], 4)
return render(request, 'shop/product/detail.html',
{'product': product,
'cart_product_form': cart_product_form,
'recommended_products': recommended_products})
def get_context_data(self, **kwargs):
"""
Add product to cart.
Suggest products for this product [[recommender.py#suggest_products_for]].
"""
context = super().get_context_data(**kwargs)
product = super().get_object()
r = Recommender()
context['cart_product_form'] = CartAddProductForm()
context['recommended_products'] = r.suggest_products_for([product], 4)
return context
def product_detail(request, id, slug):
product = get_object_or_404(Product, id=id, slug=slug, available=True)
form = DetailProduct
r = Recommender()
recommended_products = r.suggest_products_for([product], 4)
context = {
'product': product,
'form': form,
'recommended_products': recommended_products
}
template = 'products_detail.html'
return render(request, template, context)
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'])
# name=item['name'])
# last line 'name' ^^^ is addtional, in order to list names dircetly for recommender, as oppsed to a separate query
# This is non-functional at present, it will only return a list of numbers as a foriegn key as opposed to one name
# of the product as originally intended.
# cart_product_objects = [item['product'] for item in cart] - original iteration causes a tuple unpacking error.
cart_product_objects = [item['product'] for item in cart]
print(type(cart_product_objects))
print(cart_product_objects)
for item in cart_product_objects:
print(item)
# Update recommender
r = Recommender()
r.products_bought(cart_product_objects)
# clear the cart
cart.clear()
# The system to send a confirmation email below is disabled due to system incompatibility.
# launch asynchronous task
# order_created.delay(order.id)
# set the order in the session
request.session['order_id'] = order.id
# redirect for payment. Original version passed the objects list to the payment section,
# however this caused multiple errors through a problem GET request that were best resolved here.
return redirect(
reverse('payment:process')) #, cart_product_objects
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def cart_detail(request):
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(
initial={'quantity': item['quantity'],
'update': True})
# will see about coupons
r = Recommender()
cart_products = [item['product'] for item in cart]
recommended_products = r.suggest_products_for(cart_products, max_results=4)
return render(request,
'cart/detail.html',
{'cart': cart,
'recommended_products': recommended_products})
def cart_detail(request):
cart = Cart(request)
# allow users change quantity on the cart detail page
for item in cart:
item['update_quantity_form'] = CartAddProductForm(initial={
'quantity': item['quantity'],
'override': True})
coupon_apply_form = CouponApplyForm()
r = Recommender()
cart_products = [item['product'] for item in cart]
recommended_products = r.suggest_products_for(cart_products,max_results=4)
return render(request, 'cart/detail.html', {'cart': cart, 'coupon_apply_form': coupon_apply_form,
'recommended_products': recommended_products
})
