def product(request, slug, template="shop/product.html", form_class=AddProductForm, extra_context=None): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([ dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations ]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form } context.update(extra_context or {}) templates = [u"shop/%s.html" % str(product.slug), template] return TemplateResponse(request, templates, context)
def update_formset(self): cart_formset = self.get_cart_formset() if self.request.cart.has_items() is False: warning(self.request, _("Cart is empty")) elif cart_formset.is_valid(): cart_formset.save() recalculate_cart(self.request) billship_handler(self.request, None) tax_handler(self.request, None) info(self.request, _('Cart updated')) else: error(self.request, _('Invalid cart update')) order_form = self.get_order_form(checkout.CHECKOUT_STEP_FIRST) if order_form.is_valid(): self.request.session['order'] = dict(order_form.cleaned_data) else: error(self.request, _('Invalid customer details')) context = self.get_context_data() context['cart_formset'] = self.get_cart_formset() context['order_form'] = order_form return context
def create(self, request, *args, **kwargs): sku, quantity = self.get_data(request.data) variation = self.get_variation(sku) if variation is None: return no_sku_error() kwargs = {"sku": variation.sku, "unit_price": variation.price()} in_cart = request.cart.items.filter(**kwargs).first() if in_cart is not None: if quantity <= 0: in_cart.delete() else: if variation.has_stock(quantity) is False: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available) in_cart.quantity = quantity in_cart.save() elif quantity > 0: request.cart.add_item(variation, quantity) recalculate_cart(request) able_to_purchase = variation is not None and variation.has_stock( quantity) not_enough_stock = variation is not None and variation.has_stock( quantity) is False if able_to_purchase: return Response(CartSerializer(request.cart).data) elif not_enough_stock: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available)
def add_product(request, form_class=AddProductForm): """ Display a product - handling adding the product the off canvas cart. """ m = re.search(r"/product/(.*)/$", request.POST.get("slug")) slug = m.group(1) published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) if request.is_ajax() and request.POST: to_cart = request.POST.get("add_cart") add_product_form = form_class(request.POST or None, product=product, to_cart=to_cart) if to_cart: if add_product_form.is_valid(): quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) info(request, _("Item added to cart")) recalculate_cart(request) return update_cart(request) else: error = add_product_form.non_field_errors()[0] return JsonResponse({'error': error}) else: raise Http404
def create(self, request, *args, **kwargs): sku, quantity = self.get_data(request.data) variation = self.get_variation(sku) if variation is None: return no_sku_error() kwargs = {"sku": variation.sku, "unit_price": variation.price()} in_cart = request.cart.items.filter(**kwargs).first() if in_cart is not None: if quantity <= 0: in_cart.delete() else: if variation.has_stock(quantity) is False: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available) in_cart.quantity = quantity in_cart.save() elif quantity > 0: request.cart.add_item(variation, quantity) recalculate_cart(request) able_to_purchase = variation is not None and variation.has_stock(quantity) not_enough_stock = variation is not None and variation.has_stock(quantity) is False if able_to_purchase: return Response(CartSerializer(request.cart).data) elif not_enough_stock: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available)
def membership(request, slug): slugs = [slug, 'membership/%s' % slug] the_category = None for categ in Category.objects.all(): if categ.slug in slugs: the_category = categ break if not the_category: log.debug('Sorry, could not find membership types matching "%s"' % slug) return HttpResponseRedirect('/') if request.method == 'POST': variation_id = int(request.POST.get('variation_id')) variation = ProductVariation.objects.get(id=variation_id) request.cart.add_item(variation, 1) recalculate_cart(request) messages.success(request, "Your membership has been added to cart") request.session['aftercheckout'] = request.GET.get('next', '/') if request.cart.total_price(): return redirect("shop_checkout") else: # For free membership, just fake the purchase process order = Order.objects.create() order.setup(request) order.complete(request) request.user.profile.set_membership_order(order) request.user.profile.save() checkout.send_order_email(request, order) return redirect("shop_complete") context = RequestContext(request, locals()) return render_to_response('bccf/membership/membership.html', {}, context_instance=context)
def get_carrier(request): if request.is_ajax() and request.method == 'POST': if not request.POST.get("free_shipping"): carrier = request.POST['carrier'] shipping_type = request.POST['shipping_type'] shipping_total = float(carrier.split()[3][1:]) settings.use_editable() set_shipping(request, shipping_type, shipping_total) recalculate_cart(request) else: shipping_type = 'Regular Shipping' shipping_total = 0.0 set_shipping(request, shipping_type, shipping_total) subtotal = float(request.cart.total_price()) discount = float(request.session.get('discount_total', '0.00')) total = subtotal - discount + shipping_total total = "{0:.2f}".format(total) #resp = render_to_string('shop/cart.html', { 'request': request }) return HttpResponse(json.dumps({ 'shipping_type': shipping_type, 'shipping_total': shipping_total, 'total_price': total, 'discount': discount, 'subtotal': subtotal }), content_type='application/json')
def event_payment(request, event_id): user = request.user event_reg = get_object_or_404(EventRegistration, ~Q(paid=True), event=event_id, user=user) event = event_reg.event variation = ProductVariation.objects.get(sku='EVENT-%s' % event.pk) request.cart.add_item(variation, 1) recalculate_cart(request) return redirect('shop/checkout')
def product(request, slug, template="shop/product.html", form_class=AddProductForm, extra_context=None): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form } context.update(extra_context or {}) templates = [u"shop/%s.html" % str(product.slug), template] # Check for a template matching the page's content model. if getattr(product, 'content_model', None) is not None: templates.insert(0, u"shop/products/%s.html" % product.content_model) return TemplateResponse(request, templates, context)
def cart( request, template="shop/cart.html", cart_formset_class=CartItemFormSet, discount_form_class=DiscountForm, extra_context=None, ): """ Display cart and handle removing items from the cart. """ cart_formset = cart_formset_class(instance=request.cart) discount_form = discount_form_class(request, request.POST or None) if request.method == "POST": valid = True if request.POST.get("update_cart"): valid = request.cart.has_items() if not valid: # Session timed out. info(request, _("Your cart has expired")) else: cart_formset = cart_formset_class(request.POST, instance=request.cart) valid = cart_formset.is_valid() if valid: cart_formset.save() recalculate_cart(request) info(request, _("Cart updated")) else: # Reset the cart formset so that the cart # always indicates the correct quantities. # The user is shown their invalid quantity # via the error message, which we need to # copy over to the new formset here. errors = cart_formset._errors cart_formset = cart_formset_class(instance=request.cart) cart_formset._errors = errors else: valid = discount_form.is_valid() if valid: discount_form.set_discount() # Potentially need to set shipping if a discount code # was previously entered with free shipping, and then # another was entered (replacing the old) without # free shipping, *and* the user has already progressed # to the final checkout step, which they'd go straight # to when returning to checkout, bypassing billing and # shipping details step where shipping is normally set. recalculate_cart(request) if valid: return redirect("shop_cart") context = {"cart_formset": cart_formset} context.update(extra_context or {}) settings.clear_cache() if settings.SHOP_DISCOUNT_FIELD_IN_CART and DiscountCode.objects.active( ).exists(): context["discount_form"] = discount_form return TemplateResponse(request, template, context)
def get_discount_on_update(request, discount_form_class=DiscountForm): discount_form = discount_form_class(request, request.POST or None) valid = discount_form.is_valid() if valid: discount_form.set_discount() recalculate_cart(request) discount_total = float("{0:.2f}".format(float(request.session.get('discount_total','0.00')))) else: discount_total = 0 return discount_total
def cart(request, template="shop/cart.html", cart_formset_class=CartItemFormSet, discount_form_class=DiscountForm, extra_context=None): """ Display cart and handle removing items from the cart. """ cart_formset = cart_formset_class(instance=request.cart) discount_form = discount_form_class(request, request.POST or None) if request.method == "POST": valid = True if request.POST.get("update_cart"): valid = request.cart.has_items() if not valid: # Session timed out. info(request, _("Your cart has expired")) else: cart_formset = cart_formset_class(request.POST, instance=request.cart) valid = cart_formset.is_valid() if valid: cart_formset.save() recalculate_cart(request) info(request, _("Cart updated")) else: # Reset the cart formset so that the cart # always indicates the correct quantities. # The user is shown their invalid quantity # via the error message, which we need to # copy over to the new formset here. errors = cart_formset._errors cart_formset = cart_formset_class(instance=request.cart) cart_formset._errors = errors else: valid = discount_form.is_valid() if valid: discount_form.set_discount() # Potentially need to set shipping if a discount code # was previously entered with free shipping, and then # another was entered (replacing the old) without # free shipping, *and* the user has already progressed # to the final checkout step, which they'd go straight # to when returning to checkout, bypassing billing and # shipping details step where shipping is normally set. recalculate_cart(request) if valid: return redirect("shop_cart") context = {"cart_formset": cart_formset} context.update(extra_context or {}) settings.use_editable() if (settings.SHOP_DISCOUNT_FIELD_IN_CART and DiscountCode.objects.active().exists()): context["discount_form"] = discount_form return TemplateResponse(request, template, context)
def add_to_cart(request): if not request.method == 'POST': print('AAAA') return HttpResponse({}, status=400) print(request.POST) slug = request.POST.get('product-slug') published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = json.dumps([ dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations ]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = AddProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": print(add_product_form) if add_product_form.is_valid(): if to_cart: print('PRODUCT_FORM', add_product_form) quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) #info(request, _("Item added to cart")) #return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) #info(requesadd_to_cartt, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) #return response data = { 'total_price': format(request.cart.total_price(), '.2f'), 'total_quantity': request.cart.total_quantity(), 'wishlist': len(request.wishlist) } print(data) return HttpResponse(json.dumps(data), content_type="application/json")
def get_discount_on_update(request, discount_form_class=DiscountForm): discount_form = discount_form_class(request, request.POST or None) valid = discount_form.is_valid() if valid: discount_form.set_discount() recalculate_cart(request) discount_total = float("{0:.2f}".format( float(request.session.get('discount_total', '0.00')))) else: discount_total = 0 return discount_total
def get_discount(request, discount_form_class=DiscountForm): if request.method == 'POST' and request.is_ajax(): discount_form = discount_form_class(request, request.POST or None) ship_type = request.session.get('shipping_type','Shipping fee:') ship_total = request.session.get('shipping_total','0.00') valid = discount_form.is_valid() if valid: discount_form.set_discount() recalculate_cart(request) discount_total = float(request.session.get('discount_total',0)) return HttpResponse(json.dumps({'discount_total': "{0:.2f}".format(discount_total), 'cart_total':float(request.cart.total_price()),'shipping_total':ship_total, 'shipping_type':ship_type}), mimetype="application/json") else: return HttpResponse(json.dumps(discount_form.errors), content_type="application/json")
def wishlist( request, template="shop/wishlist.html", form_class=AddProductForm, extra_context=None, ): """ Display the wishlist and handle removing items from the wishlist and adding them to the cart. """ if not settings.SHOP_USE_WISHLIST: raise Http404 skus = request.wishlist error = None if request.method == "POST": to_cart = request.POST.get("add_cart") add_product_form = form_class(request.POST or None, to_cart=to_cart) if to_cart: if add_product_form.is_valid(): request.cart.add_item(add_product_form.variation, 1) recalculate_cart(request) message = _("Item added to cart") url = "shop_cart" else: error = list(add_product_form.errors.values())[0] else: message = _("Item removed from wishlist") url = "shop_wishlist" sku = request.POST.get("sku") if sku in skus: skus.remove(sku) if not error: info(request, message) response = redirect(url) set_cookie(response, "wishlist", ",".join(skus)) return response # Remove skus from the cookie that no longer exist. published_products = Product.objects.published(for_user=request.user) f = {"product__in": published_products, "sku__in": skus} wishlist = ProductVariation.objects.filter(**f).select_related("product") wishlist = sorted(wishlist, key=lambda v: skus.index(v.sku)) context = {"wishlist_items": wishlist, "error": error} context.update(extra_context or {}) response = TemplateResponse(request, template, context) if len(wishlist) < len(skus): skus = [variation.sku for variation in wishlist] set_cookie(response, "wishlist", ",".join(skus)) return response
def product(request, slug, template="shop/product.html"): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = AddProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": product.related_products.published( for_user=request.user), "add_product_form": add_product_form } templates = [u"shop/%s.html" % unicode(product.slug), template] return render(request, templates, context)
def wishlist(request, template="shop/wishlist.html", form_class=AddProductForm, extra_context=None): """ Display the wishlist and handle removing items from the wishlist and adding them to the cart. """ if not settings.SHOP_USE_WISHLIST: raise Http404 skus = request.wishlist error = None if request.method == "POST": to_cart = request.POST.get("add_cart") add_product_form = form_class(request.POST or None, to_cart=to_cart) if to_cart: if add_product_form.is_valid(): request.cart.add_item(add_product_form.variation, 1) recalculate_cart(request) message = _("Item added to cart") url = "shop_cart" else: error = list(add_product_form.errors.values())[0] else: message = _("Item removed from wishlist") url = "shop_wishlist" sku = request.POST.get("sku") if sku in skus: skus.remove(sku) if not error: info(request, message) response = redirect(url) set_cookie(response, "wishlist", ",".join(skus)) return response # Remove skus from the cookie that no longer exist. published_products = Product.objects.published(for_user=request.user) f = {"product__in": published_products, "sku__in": skus} wishlist = ProductVariation.objects.filter(**f).select_related("product") wishlist = sorted(wishlist, key=lambda v: skus.index(v.sku)) context = {"wishlist_items": wishlist, "error": error} context.update(extra_context or {}) response = TemplateResponse(request, template, context) if len(wishlist) < len(skus): skus = [variation.sku for variation in wishlist] set_cookie(response, "wishlist", ",".join(skus)) return response
def register_event(request): """ Registers users to the event, registerer must complete registration using checkout if the event is not free """ from cartridge.shop.utils import recalculate_cart from bccf.models import Event, EventRegistration member_ids = request.session['register_selected_members'] event_id = request.session['register_selected_event'] response = redirect(reverse('update')) message = 'Users registered successfully.' event = Event.objects.get(id=event_id) seats = len(EventRegistration.objects.filter(event=event)) + len(member_ids) if event.max_seats < seats: # Not everyone will fit error(request, 'There is not enough space in the event for your members.') return response if event.event_product: # If paid event, add event to cart variation = ProductVariation.objects.get(sku='EVENT-%s' % event.pk) request.cart.add_item(variation, len(member_ids)) recalculate_cart(request) response = redirect('/shop/checkout') message = 'Users registered successfully. Please continue with the checkout to complete registrations.' # Send event registration confirmation send_reminder("Event Registration Pending.", request.user, context={'event':event}) else: # If not paid event, auto-register the members members = [] for member_id in member_ids: user = User.objects.get(id=member_id) members.append(user) EventRegistration.objects.create(user=user, event=event) send_reminder("Event Registration Complete.", user, context={'event': event}) # Send event registration confirmation send_reminder("Event Registration Complete.", request.user, context={'event': event, 'members': members}) # Delete session variables since the IDs have been registered del request.session['register_selected_members'] del request.session['register_selected_event'] success(request, message) return response
def signup(request, slug): if 'aftercheckout' in request.session: del request.session['aftercheckout'] event = Event.objects.get(slug=slug) if request.method == 'POST': # Check if such registration already exists exists = False if not event.is_full(): for existing in EventRegistration.objects.filter(user=request.user, event=event): messages.warning(request, 'You are already signed up to this event') exists = True if not exists: if event.event_product: variation = ProductVariation.objects.get(sku='EVENT-%s' % event.pk) request.cart.add_item(variation, 1) recalculate_cart(request) messages.success(request, 'To complete the registration, please go through the checkout.') # Send event registration confirmation send_reminder("Event Registration Pending.", request.user, context={'event':event}) else: registration = EventRegistration.objects.create(user=request.user, event=event) # Send event registration confirmation send_reminder("Event Registration Complete.", request.user, context={'event':event}) messages.success(request, 'Thank you! You signed up to the event successfully.') if event.max_seats == len(EventRegistration.objects.filter(event=event)): event.full = True event.save() # Send event registration for provider attendees = EventRegistration.objects.filter(event=event) send_reminder("Event is now full", event.provider, context={'event':event, 'attendees':attendees}) # Send event registration for provider send_reminder("A user registered for your event", event.provider, context={'event':event, 'attendee':request.user}) else: messages.warning(request, 'The event is full.') return HttpResponseRedirect(event.get_absolute_url()) context = RequestContext(request, locals()) return render_to_response('bccf/event_signup.html', {}, context_instance=context)
def create(self, request, *args, **kwargs): sku, quantity = self.get_data(request.data) variation = self.get_variation(sku) if variation is None: return no_sku_error() able_to_purchase = variation is not None and variation.has_stock(quantity) not_enough_stock = variation is not None and variation.has_stock(quantity) is False if able_to_purchase: request.cart.add_item(variation, quantity) recalculate_cart(request) return Response(CartSerializer(request.cart).data) elif not_enough_stock: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available)
def signup(request): # Optional queries membership_type = request.GET.get('type', None) membership_level = request.GET.get('level', None) payment_frequency = request.GET.get('freq', None) form = f.CreateAccountForm(initial={'membership_type': membership_type, 'membership_level': membership_level, 'payment_frequency': payment_frequency}) if request.method == 'POST': form = f.CreateAccountForm(data=request.POST, files=request.FILES) if form.is_valid(): response = redirect('update') if form.cleaned_data.get('membership_level') != 'A': """ If SKU exists in the query string and the SKU fits with the membership type, add that product to the cart and redirect the user to the checkout """ membership_type = form.cleaned_data.get('membership_type')[:3].upper() sku = '%s-%s-%s' % (membership_type, form.cleaned_data.get('membership_level'), form.cleaned_data.get('payment_frequency')) variation = ProductVariation.objects.get(sku=sku) request.cart.add_item(variation, 1) recalculate_cart(request) response = redirect('shop_checkout') form.save() subscribe(request, 'af67fb20e3', form.cleaned_data.get('email')) # Members list if form.cleaned_data.get('in_mailing_list'): subscribe(request, '8aebc01ca2', form.cleaned_data.get('email')) # News Letter new_user = authenticate(username=form.cleaned_data.get('username'), password=form.cleaned_data.get('password1')) auth_login(request, new_user) # Send welcome message send_welcome(new_user) send_moderate("New user signed up.", context={'user': new_user}) success(request, 'User created successfully! Welcome to the BCCF community %s' % form.instance.get_full_name()) return response context = RequestContext(request, locals()) return render_to_response('accounts/account_signup.html', {}, context)
def cart(request, template="shop/cart.html"): """ Display cart and handle removing items from the cart. """ cart_formset = CartItemFormSet(instance=request.cart) discount_form = DiscountForm(request, request.POST or None) if request.method == "POST": valid = True if request.POST.get("update_cart"): valid = request.cart.has_items() if not valid: # Session timed out. info(request, _("Your cart has expired")) else: cart_formset = CartItemFormSet(request.POST, instance=request.cart) valid = cart_formset.is_valid() if valid: cart_formset.save() recalculate_cart(request) info(request, _("Cart updated")) else: # Reset the cart formset so that the cart # always indicates the correct quantities. # The user is shown their invalid quantity # via the error message, which we need to # copy over to the new formset here. errors = cart_formset._errors cart_formset = CartItemFormSet(instance=request.cart) cart_formset._errors = errors else: valid = discount_form.is_valid() if valid: discount_form.set_discount() if valid: return redirect("shop_cart") context = {"cart_formset": cart_formset} settings.use_editable() no_discounts = not DiscountCode.objects.active().exists() discount_applied = "discount_code" in request.session discount_in_cart = settings.SHOP_DISCOUNT_FIELD_IN_CART if not no_discounts and not discount_applied and discount_in_cart: context["discount_form"] = discount_form return render(request, template, context)
def formsets_valid(self, ticket_option_formset, product_formset): for form in itertools.chain(ticket_option_formset, product_formset): try: # If it's a ticket option variation = form.ticket_option except AttributeError: # If it's a product already variation = form.cleaned_data['id'] quantity = form.cleaned_data['quantity'] if quantity > 0: self.request.cart.add_item(variation=variation, quantity=quantity) tax_handler(self.request, None) recalculate_cart(self.request) return redirect('salesbro:portal_cart')
def create(self, request, *args, **kwargs): sku, quantity = self.get_data(request.data) variation = self.get_variation(sku) if variation is None: return no_sku_error() able_to_purchase = variation is not None and variation.has_stock( quantity) not_enough_stock = variation is not None and variation.has_stock( quantity) is False if able_to_purchase: request.cart.add_item(variation, quantity) recalculate_cart(request) return Response(CartSerializer(request.cart).data) elif not_enough_stock: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available)
def CustomSizeStep(request, slug, template="multiStepForm/customSizesStepForm.html"): form = CustomSizeStepForm(request.POST or None, request=request) if request.method == 'POST': if form.is_valid(): sizeData = form.cleaned_data #add dimensions to request.session json #checking to see if dimensions are among json fields # for field in request.session.iteritems(): # print "data/fields in SUBMITTED DIMENSIONS: " + str(field) variation = ProductVariation.objects.get( product__sku=request.session['sku']) variation.height = sizeData['height'] variation.weight = sizeData['weight'] variation.neck_size = sizeData['neck_size'] variation.chest_around = sizeData['chest_around'] variation.sleeve_length = sizeData['sleeve_length'] variation.wrist_size = sizeData['wrist_size'] variation.full_back_length = sizeData['full_back_length'] variation.half_back_length = sizeData['half_back_length'] variation.full_shoulder_width = sizeData['full_shoulder_width'] variation.stomach = sizeData['stomach'] variation.waist_size = sizeData['waist_size'] variation.hip_size = sizeData['hip_size'] variation.pants_length = sizeData['pants_length'] variation.crotch_size = sizeData['crotch_size'] variation.fabrics = Fabric.objects.get( name=request.session['fabrics']) request.cart.add_item(variation, int(request.session['quantity'])) recalculate_cart(request) return redirect("shop_cart") context = {"form": form} return render(request, template, context)
def update_cart(request, template="shop/includes/offcanvas_cart.html", cart_formset_class=OffCartItemFormSet): """ Display cart and handle removing items from the cart. """ cart_formset = cart_formset_class(instance=request.cart) if request.is_ajax(): if request.POST and request.POST.get("update_cart"): valid = request.cart.has_items() if not valid: # Session timed out. info(request, _("Your cart has expired")) else: cart_formset = cart_formset_class(request.POST, instance=request.cart) valid = cart_formset.is_valid() if valid: cart_formset.save() info(request, _("Cart updated")) recalculate_cart(request) cart_formset = cart_formset_class(instance=request.cart) else: # Reset the cart formset so that the cart # always indicates the correct quantities. # The user is shown their invalid quantity # via the error message, which we need to # copy over to the new formset here. errors = cart_formset._errors cart_formset = cart_formset_class(instance=request.cart) cart_formset._errors = errors elif request.POST and request.POST.get("add_cart"): cart_formset = cart_formset_class(instance=request.cart) context = {"off_cart_formset": cart_formset} settings.clear_cache() return TemplateResponse(request, template, context) else: raise Http404
def get_carrier(request): if request.is_ajax() and request.method == 'POST': if not request.POST.get("free_shipping"): carrier = request.POST['carrier'] shipping_type = request.POST['shipping_type'] shipping_total = float(carrier.split()[3][1:]) settings.use_editable() set_shipping(request, shipping_type, shipping_total) recalculate_cart(request) else: shipping_type = 'Regular Shipping' shipping_total = 0.0 set_shipping(request, shipping_type, shipping_total) subtotal = float(request.cart.total_price()) discount = float(request.session.get('discount_total','0.00')) total = subtotal - discount + shipping_total total = "{0:.2f}".format(total) #resp = render_to_string('shop/cart.html', { 'request': request }) return HttpResponse(json.dumps({'shipping_type' : shipping_type, 'shipping_total' : shipping_total, 'total_price' : total, 'discount':discount, 'subtotal':subtotal}), content_type='application/json')
def get_discount(request, discount_form_class=DiscountForm): if request.method == 'POST' and request.is_ajax(): discount_form = discount_form_class(request, request.POST or None) ship_type = request.session.get('shipping_type', 'Shipping fee:') ship_total = request.session.get('shipping_total', '0.00') valid = discount_form.is_valid() if valid: discount_form.set_discount() recalculate_cart(request) discount_total = float(request.session.get('discount_total', 0)) return HttpResponse(json.dumps({ 'discount_total': "{0:.2f}".format(discount_total), 'cart_total': float(request.cart.total_price()), 'shipping_total': ship_total, 'shipping_type': ship_type }), mimetype="application/json") else: return HttpResponse(json.dumps(discount_form.errors), content_type="application/json")
def wishlist(request, template="shop/wishlist1.html"): """ Display the wishlist and handle removing items from the wishlist and adding them to the cart. """ if not settings.SHOP_USE_WISHLIST: raise Http404 skus = request.wishlist error = None if request.method == "POST": print request.POST print "nihao" to_cart = request.POST.get("add_cart") print len(to_cart) print "to_cart:"+to_cart #{u'sku': [u'28'], u'csrfmiddlewaretoken': [u'P5IBTacZNNoP6QzaVPMScIdje3cGBEbv'], u'add_cart': [u'Buy'], u'quantity': [u'1']}> # test={u'sku': [u'28'], u'csrfmiddlewaretoken': [u'P5IBTacZNNoP6QzaVPMScIdje3cGBEbv'], u'add_cart': [u'Buy'], u'quantity': [u'1']} # add_product_form = AddProductForm(test or None, # to_cart=to_cart) # # print request.POST # print add_product_form if len(to_cart)>10: pass tmp_post=request.POST.copy() wish_skus=tmp_post.getlist("sku") if wish_skus=="none": message = _("error in wishlist") # print "wish_skus:" + wish_skus for i in wish_skus: tmp_post.__setitem__("sku",i) add_product_form = AddProductForm(tmp_post or None, to_cart=to_cart) if add_product_form.is_valid(): request.cart.add_item(add_product_form.variation, 1) recalculate_cart(request) else: error = list(add_product_form.errors.values())[0] # print "error:"+str(skus) skus.remove(i) message = _("Items added to cart") url = "shop_cart" elif to_cart: add_product_form = AddProductForm(request.POST or None, to_cart=to_cart) if add_product_form.is_valid(): request.cart.add_item(add_product_form.variation, 1) print add_product_form.variation recalculate_cart(request) message = _("Item added to cart") url = "shop_cart" else: error = list(add_product_form.errors.values())[0] else: add_product_form = AddProductForm(request.POST or None, to_cart=to_cart) message = _("Item removed from wishlist") url = "shop_wishlist" sku = request.POST.get("sku") print request.POST.get("sku") print skus if sku in skus: skus.remove(sku) if not error: info(request, message) response = redirect(url) set_cookie(response, "wishlist", ",".join(skus)) return response # Remove skus from the cookie that no longer exist. published_products = Product.objects.published(for_user=request.user) f = {"product__in": published_products, "sku__in": skus} wishlist = ProductVariation.objects.filter(**f).select_related(depth=1) wishlist = sorted(wishlist, key=lambda v: skus.index(v.sku)) context = {"wishlist_items": wishlist, "error": error} response = render(request, template, context) if len(wishlist) < len(skus): skus = [variation.sku for variation in wishlist] set_cookie(response, "wishlist", ",".join(skus)) return response
def product(request, slug, template="shop/product.html", form_class=AddProductForm): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect(request.path) else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form, "categories": product.categories.all()[0].get_ascendants()[::-1] + [product.categories.all()[0]] } # templates = [u"shop/%s.html" % str(product.slug), template] templates = [] # Check for a template matching the page's content model. if product.content_model is not None and product.content_model != 'product': templates.append(u"shop/products/%s.html" % product.content_model) context["characteristics"] = product.get_content_model().get_characteristics() if product.content_model in ('productportal', 'productfacing'): context["suitable_hearth"] = product.get_content_model().suitable_hearth.published(for_user=request.user) context["suitable_topka"] = product.get_content_model().suitable_topka.published(for_user=request.user) if product.content_model in ('producthearth', 'producttopka'): context["suitable_faces"] = product.get_content_model().suitable_faces.published(for_user=request.user) context["suitable_portals"] = product.get_content_model().suitable_portals.published(for_user=request.user) templates.append(template) return render(request, templates, context)
def membership_confirm(request, level, template="profiles/membership_confirm.html"): """ http://stackoverflow.com/questions/38566456/how-to-run-a-celery-worker-on-aws-elastic-beanstalk http://stackoverflow.com/questions/12813586/running-pythons-celery-on-elastic-beanstalk-with-django http://stackoverflow.com/questions/14761468/how-do-you-run-a-worker-with-aws-elastic-beanstalk http://stackoverflow.com/questions/26851257/can-celery-run-on-elastic-beanstalk http://stackoverflow.com/questions/41231489/run-celery-with-django-on-aws-elastic-beanstalk-using-environment-variables https://www.caktusgroup.com/blog/2011/12/19/using-django-and-celery-amazon-sqs/ http://kronosapiens.github.io/blog/2015/04/28/rabbitmq-aws.html http://stackoverflow.com/questions/8048556/celery-with-amazon-sqs http://pkj.no/2015/12/deploying-modern-django-apps-to-aws-beanstalk/ https://www.reddit.com/r/django/comments/3eei3s/celery_and_aws/ http://stackoverflow.com/questions/15079176/should-django-model-object-instances-be-passed-to-celery vvvvvvvvvvvvvvvv http://docs.celeryproject.org/en/latest/getting-started/brokers/sqs.html ^^^^^^^^^^^^^^^^^ :param request: :param level: :param template: :return: """ if level not in ["regular", "gold", "diamond"]: return redirect("change_membership_view") confirm_level = settings.MEMBERSHIPS[level] lookup = {"user": request.user} membership = get_object_or_404(Membership, **lookup) # get user's membership object form = ConfirmationForm(request.POST or None, initial={'level': level}) if request.method == "POST" and form.is_valid(): # published_products = Product.objects.published(for_user=request.user) # if chosen membership product doesn't exist, create it, and its default variation member_product, created = Product.objects.get_or_create( slug=level, unit_price=settings.MEMBERSHIPS[level]["price"][0], # price_hkd=settings.MEMBERSHIPS[level]["price"][1], title="{} Membership".format(level.upper()), description="{} membership".format( level.upper())) # slug for each membership would be EN if created: variation, created_var = ProductVariation.objects.get_or_create( product=member_product, unit_price=settings.MEMBERSHIPS[level]["price"][0], price_hkd=settings.MEMBERSHIPS[level]["price"][1], default=True) member_product = member_product.variations.first( ) # this gets first variation, which has a sku, or just made quantity = 1 request.cart.add_item(member_product, quantity) recalculate_cart(request) info(request, _("Your membership will activate after purchase")) # check purchase 15 minutes # check_membership_purchase_task.apply_async((request.user.id,level),countdown=15) return redirect("shop_cart") context = { "membership": membership, "confirm_level": confirm_level, "form": form, "submit_btn": _("Confirm membership"), "title": level.capitalize() } return TemplateResponse(request, template, context) # # def test_aws_revoke(request): # from celery.result import AsyncResult # from celery.task.control import revoke # print("testing revoke") # test_task = test_aws_revoke_task.apply_async(countdown=15) # test_task.revoke() # return TemplateResponse(request, template="test/test-revoke.html",context=None)
def buscarDominio(request): resultado = '' domain = '' dominio = '' extension = '' precio = '' duracion = 1 descripcion = '' precio_total = '' price_unit = '' if request.method == 'POST' and 'buscar' in request.POST: consulta = BuscarDominioForm(request.POST) if consulta.is_valid(): dominio = consulta.cleaned_data['dominio'] extension = consulta.cleaned_data['extension'] duracion = consulta.cleaned_data['duracion'] duracion = int(duracion) request.session['dur'] = duracion dominio = str(dominio) sufijo = str(extension) domain = dominio + '.' + sufijo request.session['dom'] = domain result = api.domain.available(apikey, [domain]) while result[domain] == 'pending': time.sleep(0.7) result = api.domain.available(apikey, [domain]) if result[domain] == 'available': resultado = domain + ' se encuentra disponible' product_spec = { 'product': { 'description': domain, 'type': 'domain' }, 'action': { 'name': 'create', 'duration': duracion } } result = api.catalog.list(apikey, product_spec) result2 = result[0] price = result2['unit_price'] price2 = price[0] price_unit = price2['price'] precio = (price_unit + 4) * 4 request.session['pr_un'] = price_unit request.session['pre'] = precio precio_total = precio * duracion break elif result[domain] == 'unavailable': resultado = domain + ' no se encuentra disponible' break request.session['res'] = resultado elif request.method == 'POST' and 'registro' in request.POST: producto = Product() dominio = request.session.get('dom') dominio = str(dominio) unit_price = request.session.get('pr_un') sale_price = request.session.get('pre') producto.unit_price = unit_price producto.sale_price = sale_price producto.num_in_stock = 30 producto.sku = Product.objects.all().count() + 1 duracion = request.session.get('dur') producto.available = True producto.title = dominio producto.save() product = ProductVariation() product.product = producto product.unit_price = unit_price product.sale_price = sale_price product.num_in_stock = 30 product.sku = ProductVariation.objects.all().count() + 1 product.save() request.cart.add_item(product, duracion) recalculate_cart(request) return HttpResponseRedirect('/shop/cart/') else: consulta = BuscarDominioForm() return render_to_response('buscadominioform.html', { 'consulta': consulta, 'resultado': resultado, 'precio': precio_total }, context_instance=RequestContext(request))
def product(request, slug, template="shop/product.html", form_class=AddProductForm, extra_context=None): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([ dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations ]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) try: # set title = membership level + product slug ("statue+gold") # discount = DiscountCode.objects.filter(title="{}+{}".format(product.sku, request.user.membership.level))[0] discount = get_or_update_discount(request, sku=product.sku) # discount_percent = (100 - discount.discount_percent)/100 discount_deduction = discount.discount_deduct except: discount_deduction = 0 try: c = CurrencyRates() hkd_rate = c.get_rate('CNY', 'HKD') except: hkd_rate = 1.1584 context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form, "discount": discount_deduction, "hkd_rate": hkd_rate } context.update(extra_context or {}) templates = [u"shop/%s.html" % str(product.slug), template] return TemplateResponse(request, templates, context)
def product(request, slug, template="shop/product.html"): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_cart") is not None) save_product = (request.method == "POST" and request.POST.get("save_product") is not None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 quote = None if product.custom_product: quote_id = request.GET.get('quote_id') if quote_id: quote = get_object_or_404(Quote, pk=quote_id) add_product_form = AddCustomProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart, quote=quote) else: add_product_form = AddProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if save_product: user_catagory = Category.objects.get(pk=15) new_product = product new_images = product.images.all() new_variations = variations for i in new_images: i.pk = None i.id = None i.save() message = add_product_form.cleaned_data["message"] flat_message = message.replace('\n', ' ') new_product.pk = None new_product.id = None new_product.sku = None new_product.title = trunc(s=flat_message).title() + " Canvas Print" new_product.slug = None new_product.custom_product = False #new_product.available = False new_product.content = new_product.content +flat_message new_product.save() new_product.categories.add(user_catagory) new_product.images = new_images data_uri = add_product_form.cleaned_data["image_data"] img_str = re.search(r'base64,(.*)', data_uri).group(1) temp_img = img_str.decode('base64') image = ProductImage(file=ContentFile(temp_img, new_product.slug+'.png'), description = message, product=new_product) image.save() for v in new_variations: v.pk = None v.id = None v.sku = None v.image = image v.save() new_product.variations = new_variations new_product.copy_default_variation() json = add_product_form.cleaned_data["json_data"] custom_product = CustomProduct(product = new_product, text = message, quote=quote, json=json) custom_product.save() return redirect("shop_product", slug=new_product.slug) elif to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": product.related_products.published( for_user=request.user), "add_product_form": add_product_form } templates = [u"shop/%s.html" % unicode(product.slug), template] return render(request, templates, context)
def product(request, slug, template="shop/product.html"): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ address = request.session['address'] if 'cart loaded' in request.session: current_store = request.session['stores'][0] else: current_store = [] published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = AddProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: if 'cart loaded' in request.session: current_store = Store.objects.filter(name__exact=product.store)[0] if current_store != request.session['stores'][0]: info(request, _("Sorry, the item cannot be added to your cart. " "By NY law you cannot shop from two different liquor stores simultaneously.")) return HttpResponseRedirect('/shop/') else: request.session['cart loaded'] = 'cart loaded' store = Store.objects.filter(name__exact=product.store) request.session['stores'] = store request.session['delivery min'] = store[0].delivery_min current_store = store[0] name = unicodedata.normalize('NFKD', current_store.name).encode('ascii','ignore') store_slug = '/shop/'+slugify(name)+'/' request.session['store slug'] = store_slug quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart. Anything else from %s?" % name )) # return redirect("shop_cart") return redirect(store_slug) else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": product.related_products.published( for_user=request.user), "add_product_form": add_product_form, "address": address, "stores": current_store, } templates = [u"shop/%s.html" % unicode(product.slug), template] # new return render(request, templates, context)
def cart(request, template="shop/cart.html"): """ Display cart and handle removing items from the cart. """ if 'delivery min' in request.session: delivery_min = request.session['delivery min'] else: delivery_min = [] if 'store slug' in request.session: store_slug = request.session['store slug'] else: store_slug = '/shop/' address = request.session['address'] current_store = [] if 'cart loaded' in request.session: current_store = request.session['stores'][0] cart_formset = CartItemFormSet(instance=request.cart) discount_form = DiscountForm(request, request.POST or None) tax_handler(request, None) if request.method == 'POST': tipform = TipForm(request.POST) if tipform.is_valid(): tip_percent = tipform.cleaned_data['tip'] tip = 0.01*float(tip_percent)*float(request.cart.total_price()) billship_handler(request, tip) # tax_handler(request, None) request.session['tip fixed'] = True else: tipform = TipForm() if 'shop_checkout' in request.POST: return redirect('/shop/checkout') elif request.method == "POST": valid = True if request.POST.get("update_cart"): valid = request.cart.has_items() if not valid: # Session timed out. if 'stores' in request.session: del request.session['stores'] if 'cart loaded' in request.session: del request.session['cart loaded'] info(request, _("Your cart has expired")) return redirect('/shop/') else: cart_formset = CartItemFormSet(request.POST, instance=request.cart) valid = cart_formset.is_valid() if valid: cart_formset.save() recalculate_cart(request) info(request, _("Cart updated")) else: # Reset the cart formset so that the cart # always indicates the correct quantities. # The user is shown their invalid quantity # via the error message, which we need to # copy over to the new formset here. errors = cart_formset._errors cart_formset = CartItemFormSet(instance=request.cart) cart_formset._errors = errors else: valid = discount_form.is_valid() if valid: discount_form.set_discount() if valid: total_quantity, number_forms, number_items_removed = 0, 0, 0 for form in cart_formset: number_forms += 1 if form.is_valid(): was_item_removed = form.cleaned_data["DELETE"] if was_item_removed: number_items_removed += 1 total_quantity += form.cleaned_data["quantity"] if number_forms==number_items_removed: if 'stores' in request.session: del request.session['stores'] if 'cart loaded' in request.session: del request.session['cart loaded'] return redirect('/shop/') elif total_quantity==0: if 'stores' in request.session: del request.session['stores'] if 'cart loaded' in request.session: del request.session['cart loaded'] # return redirect("shop_cart") return redirect('/shop/') ten_percent = 0.1*float(request.cart.total_price()) suggested_tip = '%.2f' % float((ten_percent>2.0)*ten_percent+(ten_percent <=2.0)*2.0) if 'tip fixed' in request.session: tip_fixed = True else: tip_fixed = False context = {"cart_formset": cart_formset, "delivery_min": delivery_min, "tipform": tipform, "suggested_tip": suggested_tip, "tip_fixed": tip_fixed, "store_slug": store_slug, "address": address, "stores": current_store} settings.use_editable() if (settings.SHOP_DISCOUNT_FIELD_IN_CART and DiscountCode.objects.active().count() > 0): context["discount_form"] = discount_form return render(request, template, context)
def product(request, slug, template="shop/product.html"): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) if not request.is_ajax(): page = Category.objects.get(slug__exact='shop') products = Product.objects.published(for_user=request.user ).filter(page.category.filters()).distinct() sort_options = [(slugify(option[0]), option[1]) for option in settings.SHOP_PRODUCT_SORT_OPTIONS] sort_by = request.GET.get("sort", sort_options[0][1]) products = paginate(products.order_by(sort_by), request.GET.get("page", 1), settings.SHOP_PER_PAGE_CATEGORY, settings.MAX_PAGING_LINKS) products.sort_by = sort_by sub_categories = page.category.children.published() child_categories = Category.objects.filter(id__in=sub_categories) context = RequestContext(request, locals()) return render_to_response('pages/category.html', {}, context_instance=context) else: fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = AddProductForm(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) return HttpResponse(request.cart.total_quantity()) else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": product.related_products.published( for_user=request.user), "add_product_form": add_product_form } templates = [u"shop/%s.html" % unicode(product.slug), template] return render(request, templates, context)
def membership_voting(request, type): variation = ProductVariation.objects.get(sku=type) request.cart.add_item(variation, 1) recalculate_cart(request) response = redirect('shop_checkout') return response
def product(request, slug, template="shop/product.html", form_class=AddProductForm): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] if product.content_model == 'reservableproduct': from_date = add_product_form.cleaned_data["from_date"] to_date = add_product_form.cleaned_data["to_date"] else: from_date = None to_date = None request.cart.add_item(add_product_form.variation, quantity, from_date, to_date) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) if product.content_model == 'reservableproduct': reservable = ReservableProduct.objects.get(id=product.id) reservations = reservable.reservations.all() else: reservations = None reservable = None timespecials = product.specialprices.filter(special_type='PER', to_date__gte=date.today()) try: weekendspecial = product.specialprices.get(special_type='WKD') except SpecialPrice.DoesNotExist: weekendspecial = False context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form, "reservations": reservations, "reservable": reservable, "timespecials": timespecials, "weekendspecial": weekendspecial, } templates = [u"shop/%s.html" % str(product.slug), template] # Check for a template matching the page's content model. if product.content_model is not None: templates.insert(0, u"shop/products/%s.html" % product.content_model) templates.append(template) return render(request, templates, context)
def design(request, product_slug, shop_slug, template="mukluk/designed_product.html", form_class=AddProductForm, extra_context=None): published_dps = DesignedProduct.objects.published(for_user=request.user) designed_product = get_object_or_404(published_dps, slug=product_slug) base = get_object_or_404(Product, slug=designed_product.base.slug) fields = [f.name for f in ProductVariation.option_fields()] variations = base.variations.all() variations_json = dumps([dict( [(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=base, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item( add_product_form.variation, designed_product, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect("shop_cart") else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response # related = [] # if settings.SHOP_USE_RELATED_PRODUCTS: # related = product.related_products.published(for_user=request.user) context = { "designed_product": designed_product, "product": base, "editable_obj": designed_product, "images": designed_product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), # "related_products": related, "add_product_form": add_product_form } context.update(extra_context or {}) templates = [u"mukluk/%s.html" % str(designed_product.slug), template] # Check for a template matching the page's content model. if getattr(designed_product, 'content_model', None) is not None: templates.insert(0, u"shop/products/%s.html" % designed_product.content_model) return TemplateResponse(request, templates, context)
def product(request, slug, template="shop/product.html", form_class=AddProductForm): """ Display a product - convert the product variations to JSON as well as handling adding the product to either the cart or the wishlist. """ published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) fields = [f.name for f in ProductVariation.option_fields()] variations = product.variations.all() variations_json = dumps([ dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]]) for v in variations ]) to_cart = (request.method == "POST" and request.POST.get("add_wishlist") is None) initial_data = {} if variations: initial_data = dict([(f, getattr(variations[0], f)) for f in fields]) initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=to_cart) if request.method == "POST": if add_product_form.is_valid(): if to_cart: quantity = add_product_form.cleaned_data["quantity"] request.cart.add_item(add_product_form.variation, quantity) recalculate_cart(request) info(request, _("Item added to cart")) return redirect(request.path) else: skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist")) response = redirect("shop_wishlist") set_cookie(response, "wishlist", ",".join(skus)) return response related = [] if settings.SHOP_USE_RELATED_PRODUCTS: related = product.related_products.published(for_user=request.user) context = { "product": product, "editable_obj": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related_products": related, "add_product_form": add_product_form, "categories": product.categories.all()[0].get_ascendants()[::-1] + [product.categories.all()[0]] } # templates = [u"shop/%s.html" % str(product.slug), template] templates = [] # Check for a template matching the page's content model. if product.content_model is not None and product.content_model != 'product': templates.append(u"shop/products/%s.html" % product.content_model) context["characteristics"] = product.get_content_model( ).get_characteristics() if product.content_model in ('productportal', 'productfacing'): context["suitable_hearth"] = product.get_content_model( ).suitable_hearth.published(for_user=request.user) context["suitable_topka"] = product.get_content_model( ).suitable_topka.published(for_user=request.user) if product.content_model in ('producthearth', 'producttopka'): context["suitable_faces"] = product.get_content_model( ).suitable_faces.published(for_user=request.user) context["suitable_portals"] = product.get_content_model( ).suitable_portals.published(for_user=request.user) templates.append(template) return render(request, templates, context)
def buscarDominio(request): resultado = '' domain = '' dominio = '' extension = '' precio = '' duracion = 1 descripcion = '' precio_total = '' price_unit = '' if request.method=='POST' and 'buscar' in request.POST: consulta = BuscarDominioForm(request.POST) if consulta.is_valid(): dominio = consulta.cleaned_data['dominio'] extension = consulta.cleaned_data['extension'] duracion = consulta.cleaned_data['duracion'] duracion = int(duracion) request.session['dur'] = duracion dominio = str(dominio) sufijo = str(extension) domain = dominio + '.' + sufijo request.session['dom'] = domain result = api.domain.available(apikey, [domain]) while result[domain] == 'pending': time.sleep(0.7) result = api.domain.available(apikey, [domain]) if result[domain] == 'available': resultado = domain + ' se encuentra disponible' product_spec = { 'product' : { 'description': domain, 'type': 'domain' }, 'action' : { 'name': 'create', 'duration': duracion } } result = api.catalog.list(apikey, product_spec) result2 = result[0] price = result2['unit_price'] price2 = price[0] price_unit = price2['price'] precio = (price_unit + 4)*4 request.session['pr_un'] = price_unit request.session['pre'] = precio precio_total = precio*duracion break elif result[domain] == 'unavailable': resultado = domain + ' no se encuentra disponible' break request.session['res'] = resultado elif request.method == 'POST' and 'registro' in request.POST: producto = Product() dominio = request.session.get('dom') dominio = str(dominio) unit_price = request.session.get('pr_un') sale_price = request.session.get('pre') producto.unit_price = unit_price producto.sale_price = sale_price producto.num_in_stock = 30 producto.sku = Product.objects.all().count() + 1 duracion = request.session.get('dur') producto.available = True producto.title = dominio producto.save() product = ProductVariation() product.product = producto product.unit_price = unit_price product.sale_price = sale_price product.num_in_stock = 30 product.sku = ProductVariation.objects.all().count() + 1 product.save() request.cart.add_item(product, duracion) recalculate_cart(request) return HttpResponseRedirect('/shop/cart/') else: consulta = BuscarDominioForm() return render_to_response('buscadominioform.html',{'consulta':consulta, 'resultado':resultado, 'precio':precio_total}, context_instance=RequestContext(request))
def form_valid(self, form): quantity = form.cleaned_data["quantity"] self.request.cart.add_item(form.ticket_option, quantity) recalculate_cart(self.request) info(self.request, 'Item added to cart') return redirect("shop_cart")
def wishlist(request, template="shop/wishlist1.html"): """ Display the wishlist and handle removing items from the wishlist and adding them to the cart. """ if not settings.SHOP_USE_WISHLIST: raise Http404 skus = request.wishlist error = None # print "hehe" if request.method == "POST": # print request.POST print "nihao" # to_cart = request.POST.get("add_cart").decode('utf-8').encode('GBK') to_cart = request.POST.get("add_cart") if to_cart: tmp_post=request.POST.copy() wish_skus=tmp_post.getlist("sku") if wish_skus=="none": message = _("error in wishlist") # print "wish_skus:" + wish_skus for i in wish_skus: tmp_post.__setitem__("sku",i) add_product_form = AddProductForm(tmp_post or None, to_cart=to_cart) if add_product_form.is_valid(): request.cart.add_item(add_product_form.variation, 1) recalculate_cart(request) else: error = list(add_product_form.errors.values())[0] # print "error:"+str(skus) skus.remove(i) message = _("Items added to cart") url = "shop_cart" else: add_product_form = AddProductForm(request.POST or None, to_cart=to_cart) message = _("Item removed from wishlist") url = "shop_wishlist" sku = request.POST.get("sku") print request.POST.get("sku") print skus if sku in skus: skus.remove(sku) if not error: info(request, message) response = redirect(url) set_cookie(response, "wishlist", ",".join(skus)) return response # Remove skus from the cookie that no longer exist. published_products = Product.objects.published(for_user=request.user) f = {"product__in": published_products, "sku__in": skus} wishlist = ProductVariation.objects.filter(**f).select_related(depth=1) wishlist = sorted(wishlist, key=lambda v: skus.index(v.sku)) context = {"wishlist_items": wishlist, "error": error} response = render(request, template, context) if len(wishlist) < len(skus): skus = [variation.sku for variation in wishlist] set_cookie(response, "wishlist", ",".join(skus)) return response