def product_detail(request, category_slug, slug):
"""
Return details about a specific product according to a request
Params:
- category_slug:[String] A specific ID-like string for a specific category
- slug: [String] A specific ID-like string for a specific product
Return:
-[Render]: Return a product_detail.html containing information about a specific product
"""
product = get_object_or_404(Product, slug=slug)
product.num_visits += 1
product.last_visit = datetime.now()
product.save()
# Add review
if request.method == 'POST' and request.user.is_authenticated:
stars = request.POST.get('stars', 3)
content = request.POST.get('content', '')
review = ProductReview.objects.create(product=product,
user=request.user,
stars=stars,
content=content)
return redirect('product_detail',
category_slug=category_slug,
slug=slug)
#
related_products = list(
product.category.products.all().exclude(id=product.id))
if (len(related_products) >= 3):
related_products = random.sample(related_products, 3)
imagesstring = "{'thumbnail': '%s', 'image': '%s'}," % (
product.thumbnail.url, product.image.url)
# for image in product.images.all():
# imagesstring += ("{'thumbnail': '%s', 'image': '%s'}," %(image.thumbnail.url, image.image.url))
cart = Cart(request)
if cart.has_product(product.id):
product.in_cart = True
else:
product.in_cart = False
owned_stores = utils.get_owned_stores(request)
product_form = EditProductForm(instance=product, stores=owned_stores)
context = {
'product': product,
'imagesstring': imagesstring,
'related_products': related_products,
'owned_stores': owned_stores,
'product_form': product_form,
}
return render(request, 'product_detail.html', 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.paid = True
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()
template = 'orders/order/created.html'
context = {
'order': order,
}
# Lauch asynchronous task
# order_created.delay(order.id)
return render(request, template, context)
else:
form = OrderCreateForm()
template = 'orders/order/create.html'
context = {
'cart': cart,
'form': form,
}
return render(request, template, context)
def api_checkout(request):
cart = Cart(request)
data = json.loads(request.body)
json_response = {'success': True}
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
address = data['address']
zipcode = data['zipcode']
city = data['city']
country = data['country']
orderid = checkout(request, first_name, last_name, email, address, zipcode,
city, country)
paid = True # Update payment if Stripe gets a response back
if paid:
order = Order.objects.get(pk=orderid)
order.paid = True
order.paid_amount = cart.get_total_cost()
order.save()
cart.clear() # When order is complete and paid clear the cart
return JsonResponse(json_response)
def product_detail(request, category_slug, slug):
product = get_object_or_404(Product, slug=slug)
related_products = list(
product.category.products.filter(parent=None).exclude(id=product.id))
if len(related_products) >= 50:
related_products = random.sample(related_products, 50)
if product.parent:
return redirect('product_detail',
category_slug=category_slug,
slug=product.parent.slug)
imagesstring = "{'thumbnail': '%s', 'image': '%s'}," % (
product.thumbnail.url, product.image.url)
for image in product.images.all():
imagesstring = imagesstring + ("{'thumbnail': '%s', 'image': '%s'}," %
(image.thumbnail.url, image.image.url))
cart = Cart(request)
if cart.has_product(product.id):
product.in_cart = True
else:
product.in_cart = False
context = {
'product': product,
'imagesstring': imagesstring,
'related_products': related_products
}
return render(request, 'product_detail.html', context)
def mi_carrito_pago(request):
print("ENTRO")
profile = request.user.userprofile
data = {'status': 'error'}
cart = Cart(request)
# Suma para el precio final
_subtotal = cart.summary()
info_general = InformacionGeneral.objects.get(pk=1)
taxi = info_general.taxi
if taxi:
total = _subtotal + taxi
else:
total = _subtotal
""" Bloque para pago """
# Consultamos al numero de pedido
if request.method == 'POST':
print("Soy POST")
form = PedidoForm(request.POST)
if form.is_valid():
pedido = form.save(commit=False)
pedido.cart = cart.cart
pedido.usuario = profile
pedido.numero_pedido = get_next_codigo_pedido()
pedido.precio_total = total
del request.session['CART-ID']
del request.session['numero_pedido']
profile.cart = None
profile.save()
pedido.save()
else:
print(form.errors, "<- errores!!!")
else:
print("NO SOY POST")
return JsonResponse(data)
def product_detail(request, category_slug, slug):
product = get_object_or_404(Product, slug=slug)
if product.parent:
return redirect('product_detail',
category_slug=category_slug,
slug=product.parent.slug)
imagesstring = "{'thumbnail': '%s', 'image': '%s'}," % (
product.thumbnail.url, product.image.url)
for image in product.images.all():
imagesstring = imagesstring + ("{'thumbnail': '%s', 'image': '%s'}," %
(image.thumbnail.url, image.image.url))
cart = Cart(request)
if cart.has_product(product.id):
product.in_cart = True
else:
product.in_cart = False
context = {'product': product, 'imagesstring': imagesstring}
return render(request, 'product_detail.html', context)
def api_checkout(request):
cart = Cart(request)
data = json.loads(request.body)
jsonresponse = {'success': True}
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
city = data['city']
address = data['address']
phone = data['phone']
orderid = checkout(request, first_name, last_name, email, city, address,
phone)
cod = True
if cod:
order = Order.objects.get(pk=orderid)
order.cod = True
order.amount_to_be_paid = cart.get_total_cost()
order.save()
html = render_to_string('core/email_confirmation.html')
send_mail('Order Confirmation',
'Your order has been sent',
'*****@*****.**', ['*****@*****.**', order.email],
fail_silently=True,
html_message=html)
cart.clear()
return JsonResponse(jsonresponse)
def api_checkout(request):
cart = Cart(request)
data = json.loads(request.body)
jsonresponse = {'success': True}
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
address = data['address']
zipcode = data['zipcode']
place = data['place']
orderid = checkout(request, first_name, last_name, email, address, zipcode,
place)
paid = True
if paid == True:
order = Order.objects.get(pk=orderid)
order.paid = True
order.paid_amount = cart.get_total_cost()
order.save()
cart.clear()
return JsonResponse(jsonresponse)
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
# redirect for payment
return redirect(reverse('payment:process'))
else:
form = OrderCreateForm()
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def api_checkout(request):
cart = Cart(request)
data = json.loads(request.body)
jsonresponse = {"success": True}
first_name = data["first_name"]
last_name = data["last_name"]
email = data["email"]
address = data["address"]
zipcode = data["zipcode"]
place = data["place"]
orderid = checkout(request, first_name, last_name, email, address, zipcode,
place)
paid = True
if paid == True:
order = Order.objects.get(pk=orderid)
order.paid = True
order.paid_amount = cart.get_total_cost()
order.save()
cart.clear()
return JsonResponse(jsonresponse)
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save()
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
# очистка корзины
cart.clear()
order_created(order.id)
request.session['order_id'] = order.id
# redirect to the payment
return redirect('payment:process')
# return render(request, 'orders/order/created.html',
# {'order': order})
else:
form = OrderCreateForm
return render(request, 'orders/order/create.html', {
'cart': cart,
'form': form
})
def product(request, category_slug, product_slug):
cart = Cart(request)
product = get_object_or_404(Product,
category__slug=category_slug,
slug=product_slug)
if request.method == 'POST':
form = AddToCartForm(request.POST)
if form.is_valid():
quantity = form.cleaned_data['quantity']
cart.add(product_id=product.id,
quantity=quantity,
update_quantity=False)
messages.success(request, 'The product was added to the cart')
return redirect('product',
category_slug=category_slug,
product_slug=product_slug)
else:
form = AddToCartForm()
similar_products = list(product.category.products.exclude(id=product.id))
if len(similar_products) >= 4:
similar_products = random.sample(similar_products, 4)
return render(request, 'product/product.html', {
'form': form,
'product': product,
'similar_products': similar_products
})
def order_create(request):
cart = Cart(request)
if not request.user.is_authenticated:
return redirect('cuenta:dashboard')
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.usuario = request.user
order.pagado = False
order.creado = datetime.datetime.now()
order.actualizado = datetime.datetime.now()
order.save()
productos_comp = []
for item in cart:
OrderItem.objects.create(orden=order,producto=item['product'],precio=item['price'],
cantidad=item['quantity'])
productos_comp.append(item['product'])
if settings.USE_REDIS:
r = Recommender()
r.producto_comprados(productos_comp)
# clear the cart
send_mail(
'Se ha producido una venta',
'Un cliente ha comprado algo en la web podes modificarla aca {0}orders/admin/order/{1}/pdf/'.format(
settings.BASE_URL, order.id
),
'*****@*****.**',
settings.VENTAS,
fail_silently=False,
)
cart.clear()
return render(request,'orders/order/creado.html',{'order': order})
else:
messages.warning(request, 'Debe corregir los datos para poder finalizar la compra.')
else:
ultimacompra = None
try:
ultimacompra = Order.objects.filter(usuario=request.user).order_by('-creado')
except:
pass
if ultimacompra:
print("Ultima compra: {}".format(ultimacompra[0]))
form = OrderCreateForm(initial={'nombre':ultimacompra[0].nombre if ultimacompra[0].nombre else '',
'apellido':ultimacompra[0].apellido if ultimacompra[0].apellido else '',
'email':ultimacompra[0].email if ultimacompra[0].email else '',
'direccion':ultimacompra[0].direccion,
'telefono':ultimacompra[0].telefono,
'codigopostal':ultimacompra[0].codigopostal,
'ciudad':ultimacompra[0].ciudad})
else:
print("No hay compra registrada")
form = OrderCreateForm(initial={
'nombre':'',
'apellido':'',
'email':''
})
return render(request,'orders/order/crear.html',{'cart': cart, 'form': form})
def api_remove_from_cart(request):
data = json.loads(request.body)
jsonresponse = {'success': True}
product_id = str(data['product_id'])
cart = Cart(request)
cart.remove(product_id)
return JsonResponse(jsonresponse)
def remove_from_cart(request):
print('VIEW: remove_from_cart')
curso_id = request.POST.get('product_id')
curso_id = int(curso_id)
curso = get_object_or_404(Curso, id=curso_id)
cart = Cart(request)
cart.remove(curso)
return redirect(reverse('pedidos:mi_carrito'))
def ajax_add_cart_item_by_sku(request):
size = Size.objects.get(sku=settings.BIEN_SLUG_MAG_001)
product = Item.objects.get(available_sizes__id=size.id)
cart = Cart(request)
cart.add(product, size.price)
return JsonResponse({'success': True, 'template': "New size %d" % cart.count()})
def api_remove_from_cart(request):
data = json.loads(request.body)
json_response = {'success': True}
product_id = str(
data['product_id']) # Cast as string or throws an error in console
cart = Cart(request) # Update cart to above values
cart.remove(product_id) # Remove the product from the cart
return JsonResponse(json_response)
def cart_add(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, 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:cart_detail')
def product_detail(request, category_slug, slug):
product = get_object_or_404(Product, slug=slug)
product.num_visits = product.num_visits + 1
product.last_visit = datetime.now()
product.save()
# Add review
if request.method == 'POST' and request.user.is_authenticated:
stars = request.POST.get('stars', 3)
content = request.POST.get('content', '')
review = ProductReview.objects.create(product=product,
user=request.user,
stars=stars,
content=content)
return redirect('product_detail',
category_slug=category_slug,
slug=slug)
#
related_products = list(
product.category.products.filter(parent=None).exclude(id=product.id))
if len(related_products) >= 3:
related_products = random.sample(related_products, 3)
if product.parent:
return redirect('product_detail',
category_slug=category_slug,
slug=product.parent.slug)
imagesstring = "{'thumbnail': '%s', 'image': '%s'}," % (
product.thumbnail.url, product.image.url)
for image in product.images.all():
imagesstring = imagesstring + ("{'thumbnail': '%s', 'image': '%s'}," %
(image.thumbnail.url, image.image.url))
cart = Cart(request)
if cart.has_product(product.id):
product.in_cart = True
else:
product.in_cart = False
context = {
'product': product,
'imagesstring': imagesstring,
'related_products': related_products
}
return render(request, 'product_detail.html', context)
def checkout(request):
cart = Cart(request)
total_cost = cart.get_total_cost()
if request.method == "POST":
form = CheckOutForm
if form.is_valid():
Cart(request).clear()
return redirect('successpage')
form = CheckOutForm
return render(request, 'checkout.html', {'cost': total_cost, 'form': form})
def ajax_validation_magazine_order_form(request, product_id):
product = get_object_or_404(Product, id=product_id)
order_form = ProductOrderingForm(data=request.POST, instance=product)
if order_form.is_valid():
cart = Cart(request)
cart.add(product,
product.available_sizes().first().price,
order_form.cleaned_data['amount'])
return JsonResponse({'success': True})
return JsonResponse(order_form.errors.as_json(), status=400, safe=False)
def ajax_update_cart_item(request):
cart = Cart(request)
product = Item.objects.get(id=request.POST.get('item_product'))
cart.update(product, request.POST.get('item_quantity'), product.available_sizes.first().price,
request.POST.get('item_size'))
template = render_to_string('cart/cart_item_container.html', {
'cart': cart,
'config': config
})
return JsonResponse({'success': True, 'template': template})
def ajax_validation_order_form(request, product_id):
item = get_object_or_404(Item, id=product_id)
order_form = ProductOrderingForm(data=request.POST, instance=item)
if order_form.is_valid():
cart = Cart(request)
size = order_form.cleaned_data.get('available_sizes', None)
cart.add(item, size.price, order_form.cleaned_data['amount'], size)
success_url = reverse('products:get_cart')
return JsonResponse({'success': True, 'success_url': success_url})
return JsonResponse(order_form.errors.as_json(), status=400, safe=False)
def create_checkout_session(request):
cart = Cart(request)
stripe.api_key = settings.STRIPE_API_KEY_HIDDEN
items = []
for item in cart:
product = item['product']
obj = {
'price_data': {
'currency': 'usd',
'product_data': {
'name': product.title
},
'unit_amount': int(product.price * 100)
},
'quantity': item['quantity']
}
items.append(obj)
session = stripe.checkout.Session.create(
payment_method_types=['card'],
line_items=items,
mode='payment',
success_url='http://127.0.0.1:8000/cart/success/',
cancel_url='http://127.0.0.1:8000/cart/',
)
data = json.loads(request.body)
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
address = data['address']
zipcode = data['zipcode']
place = data['place']
phone = data['phone']
payment_intent = session.payment_intent
orderid = checkoutCreate(request, first_name, last_name, email, address,
zipcode, place, phone)
order = Order.objects.get(pk=orderid)
order.payment_intent = payment_intent
order.paid = True
order.paid_amount = cart.get_total_cost()
order.save()
print(items)
return JsonResponse({'session': session})
def ajax_remove_item(request, item_id):
cart = Cart(request)
product = Item.objects.get(id=item_id)
cart.remove(product, request.GET.get('item_size'))
if cart.count():
template = render_to_string('cart/cart_item_container.html', {
'cart': cart,
'config': config
})
else:
template = render_to_string('cart/empty.html', {
})
return JsonResponse({'success': True, 'template': template})
def checkout(request, first_name, last_name, email, address, zipcode, place, phone):
"""
Params:
-first_name:[String] Customer's first name
-last_name:[String] Customer's last name
-email:[String] Customer's E-mail
-address:[String] Customer's Address
-zipcode:[String] Customer's zipcode
-phone:[String] Customer's phone
Return:
-order.id : [String] The generated id from the order that just saved into the Database
"""
order = Order(first_name=first_name, last_name=last_name, \
email=email, address=address, zipcode=zipcode, place=place, phone=phone)
# If the user is authenticated then save the already saved user's info in the order's info
if request.user.is_authenticated:
order.user = request.user
order.save()
cart = Cart(request)
# Create the order
for item in cart:
OrderItem.objects.create(order=order, product=item['product'], \
price=item['price'], quantity=item['quantity'])
return order.id
def api_remove_from_cart(request):
data = json.loads(request.body)
jsonresponse = {'success': True}
product_id = str(data['product_id'])
quantity = int(data['quantity'])
cart = Cart(request)
cart.remove(product_id, quantity)
product = get_object_or_404(Product, pk=product_id)
product.num_available += quantity
product.save()
return JsonResponse(jsonresponse)
def checkout(request, first_name, last_name, email, address, zipcode, place,
country, phone):
order = Order(first_name=first_name,
last_name=last_name,
email=email,
address=address,
zipcode=zipcode,
place=place,
country=country,
phone=phone)
if request.user.is_authenticated:
order.user = request.user
order.save()
cart = Cart(request)
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
return order.id
def listado(request, slug=None):
header = "producto"
categorias = Categoria.objects.all().order_by('position')
if slug == None:
print("No hay slug")
categoria_selected = Categoria.objects.all().order_by('position')[0]
try:
cursos = Curso.objects.filter(
fk_categoria=categoria_selected).order_by('position')
except:
cursos = None
else:
print("hay slug")
categoria_selected = Categoria.objects.get(slug=slug)
# Traer los productos
cursos = Curso.objects.filter(
fk_categoria=categoria_selected).order_by('position')
""" Validador para que un curso solo pueda ser clickeable
1 vez """
try:
profile = request.user.userprofile
except:
profile = None
if profile:
cart = Cart(request)
items = cart.cart.item_set.all()
list_id_items = []
for row in items:
list_id_items.append(row.object_id)
return render(request, 'productos/listado.html', locals())
def add_to_cart(request):
product_id = request.POST.get('product_id')
quantity = 1
curso = get_object_or_404(Curso, id=product_id)
cart = Cart(request)
cart.add(curso, curso.precio, quantity)
try:
profile = UserProfile.objects.get(user__id=request.user.id)
print(profile, "<- profile")
if not profile.cart:
profile.cart = cart.cart
profile.save()
except:
return redirect(reverse('usuarios:login'))
return redirect(reverse('pedidos:mi_carrito'))
