def main(): breeds_list, links = parser_breeds() breeds_list = breeds_list[61:160] links = links[61:160] description = breeds_links_read(links) for i, breed in enumerate(breeds_list): print('Start downloading images for ' + breed) links = request_to_google_cse(API_KEY, breed, CUSTOM_SEARCH_ENGINE_ID, NUMBER_IMG_REQUIR) folder_single_breed_img = os.path.join(MEDIA_ROOT, 'uploads/product', breed) # create folder for each breed if it isn't exist if not os.path.exists(folder_single_breed_img): os.makedirs(folder_single_breed_img) new_dog_product = Product(available=True, title=breed, content=description[i]) new_dog_product.save() variation = ProductVariation(product=new_dog_product, default=True, unit_price=choice(PRICE_CHOICES), sale_from=timezone.now()) variation.save() for link in links['items']: try: img_resized = download_images_by_link( breed, link['link'], IMG_WIDTH_REQUIR, IMG_HEIGHT_REQUIR, os.path.join(MEDIA_ROOT, WATERMARK), WATERMARK_OPACITY, MEDIA_ROOT) # create a new instance of ProductImage class and link it with Product class image = ProductImage(product=new_dog_product) # assign path to image to ProductImage instance image.file = img_resized image.save() print(img_resized + ' was downloaded') except HTTPError: print('HTTP Error 403: Forbidden. Link is not valid') except OSError: print('OSError.') # Set the first instance of ProductImage as default image for default variation new_dog_product.variations.set_default_images([]) # Copy duplicate fields (``Priced`` fields) from the default variation to the product. new_dog_product.copy_default_variation()
def handle_wishlist(request, slug, form_class=AddProductForm): if request.method == 'POST' and request.is_ajax(): published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) initial_data = {} variations = product.variations.all() fields = [f.name for f in ProductVariation.option_fields()] 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=False) if add_product_form.is_valid(): skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) messages.info(request, _("Item added to wishlist")) response = render(request, 'messages.html') set_cookie(response, "wishlist", ",".join(skus)) return response return HttpResponse(json.dumps(add_product_form.errors), content_type="application/json") return HttpResponse('not post')
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) AddProductForm = get_add_product_form(product) add_product_form = AddProductForm(initial={"quantity": 1}) if request.method == "POST": to_cart = request.POST.get("add_wishlist") is None add_product_form = AddProductForm(request.POST, to_cart=to_cart) if add_product_form.is_valid(): if to_cart: Cart.objects.from_request(request).add_item( add_product_form.variation, add_product_form.cleaned_data["quantity"]) info(request, _("Item added to cart"), fail_silently=True) return HttpResponseRedirect(reverse("shop_cart")) else: skus = request.COOKIES.get("wishlist", "").split(",") sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) info(request, _("Item added to wishlist"), fail_silently=True) response = HttpResponseRedirect(reverse("shop_wishlist")) set_cookie(response, "wishlist", ",".join(skus)) return response variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in ["sku", "image_id"] + [f.name for f in ProductVariation.option_fields()]]) for v in variations]) return render_to_response(template, {"product": product, "variations_json": variations_json, "variations": variations, "images": product.images.all(), "add_product_form": add_product_form}, RequestContext(request))
def cart_item_view(request, template="shop/product.html", form_class=AddProductForm, extra_content=None, cart_id="", item_id=""): cart = Cart.objects.filter(id=cart_id).first() item = next(item for item in cart.items.iterator() if item.id == int(item_id)) published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=item.url.split('/')[-1]) 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]) variation = ProductVariation.objects.filter(sku=item.sku).first() v_json = dict([(f, getattr(variation, f)) for f in fields + ["sku", "image_id"] if getattr(variation, f) is not None]) initial_data = dict(quantity=item.quantity, **v_json) initial_data['embroidery_type'] = item.personalization.embroidery_type initial_data['value'] = item.personalization.value add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=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]), "add_product_form": add_product_form, "item": item } return render(request, template, context)
def product_api(request, slug): data, body, header = {}, {}, {} try: product = Product.objects.get(slug=slug) except Exception as e: raise e fields = [f.name for f in ProductVariation.option_fields()] body['variations'] = [p.options()[0] for p in product.variations.all()] body['variations_name'] = SHOP_OPTION_TYPE_CHOICES[0][1] print(SHOP_OPTION_TYPE_CHOICES) # body['variations'] = json.dumps([dict([(f, getattr(v, f)) # for f in fields + ["sku", "image_id"]]) for v in product.variations.all()]) body['context'] = serializers.serialize('json', [product]) body['images'] = serializers.serialize('json', product.images.all()) #body['context'] = filterData(product) header['code'] = 200 header['message'] = 'success' data['header'] = header data['body'] = body # for p in ProductOption.objects.all(): # print(p.name, SHOP_OPTION_TYPE_CHOICES[p.type-1][1]) print(body['variations']) return HttpResponse(json.dumps(data), content_type="application/json")
def test_product_image_deletion_does_not_delete_referenced_variation(self): try: from io import BytesIO except ImportError: from cStringIO import StringIO as BytesIO stream = BytesIO() from PIL import Image im = Image.new("RGB", (50, 50), "white") im.save(stream, "png") del im stream.seek(0) from django.core.files import File product = Product(title="Doodah", unit_price="2.99") product.save() image = ProductImage(product_id=product.id, file=File(stream)) image.save() ProductVariation( unit_price="1.99", product_id=product.id, default=True, image=image ).save() self.assertEqual(product.variations.count(), 1) image.delete() self.assertEqual(product.variations.count(), 1)
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_discount(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 variations_json(variations): """ Gets variations including the num_in_stock attribute into json format. """ fields = [field.name for field in ProductVariation.option_fields()] variations_json = dumps([dict([(field, str(getattr(variation, field))) if isinstance(getattr(variation, field), Decimal) else (field, getattr(variation, field)) for field in fields + ["sku", "image_id", "num_in_stock"]]) for variation in variations]) return variations_json
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: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: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 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 _add_to_cart(self, variation, quantity): """ Given a variation, creates the dict for posting to the cart form to add the variation, and posts it. """ field_names = [f.name for f in ProductVariation.option_fields()] data = dict(list(zip(field_names, variation.options()))) data["quantity"] = quantity self.client.post(variation.product.get_absolute_url(), data)
def setUp(self): product1 = Product(unit_price="1.27") product1.save() ProductVariation(unit_price="1.27", product_id=product1.id).save() ProductVariation(unit_price="1.27", product_id=product1.id).save() product2 = Product(unit_price="1.27") product2.save() ProductVariation(unit_price="1.27", product_id=product2.id).save() ProductVariation(unit_price="1.27", product_id=product2.id).save() sale = Sale(title="30% OFF - Ken Bruce has gone mad!", discount_percent="30") sale.save() sale.products.add(product1) sale.products.add(product2) sale.save()
def test_cart(self): """ Test the cart object and cart add/remove forms. """ self._product.variations.all().delete() self._product.variations.create_from_options(self._options) variation = self._product.variations.all()[0] variation.unit_price = TEST_PRICE variation.num_in_stock = TEST_STOCK * 2 variation.save() # Test initial cart. cart = Cart.objects.from_request(self.client) self.assertFalse(cart.has_items()) self.assertEqual(cart.total_quantity(), 0) self.assertEqual(cart.total_price(), Decimal("0")) # Add quantity and check stock levels / cart totals. field_names = [f.name for f in ProductVariation.option_fields()] data = dict(zip(field_names, variation.options())) data["quantity"] = TEST_STOCK self.client.post(self._product.get_absolute_url(), data) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertTrue(variation.has_stock(TEST_STOCK)) self.assertFalse(variation.has_stock(TEST_STOCK * 2)) self.assertTrue(cart.has_items()) self.assertEqual(cart.total_quantity(), TEST_STOCK) self.assertEqual(cart.total_price(), TEST_PRICE * TEST_STOCK) # Add remaining quantity and check again. self.client.post(self._product.get_absolute_url(), data) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertFalse(variation.has_stock()) self.assertTrue(cart.has_items()) self.assertEqual(cart.total_quantity(), TEST_STOCK * 2) self.assertEqual(cart.total_price(), TEST_PRICE * TEST_STOCK * 2) # Remove from cart. data = {"items-INITIAL_FORMS": 0, "items-TOTAL_FORMS": 0, "update_cart": 1} for i, item in enumerate(cart): data["items-INITIAL_FORMS"] += 1 data["items-TOTAL_FORMS"] += 1 data["items-%s-id" % i] = item.id data["items-%s-DELETE" % i] = "on" self.client.post(reverse("shop_cart"), data) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertTrue(variation.has_stock(TEST_STOCK * 2)) self.assertFalse(cart.has_items()) self.assertEqual(cart.total_quantity(), 0) self.assertEqual(cart.total_price(), Decimal("0"))
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 __init__(self, *args, **kwargs): """ Handles adding a variation to the cart or wishlist. When adding from the product page, the product is provided from the view and a set of choice fields for all the product options for this product's variations are added to the form. When the form is validated, the selected options are used to determine the chosen variation. A ``to_cart`` boolean keyword arg is also given specifying whether the product is being added to a cart or wishlist. If a product is being added to the cart, then its stock level is also validated. When adding to the cart from the wishlist page, a sku is given for the variation, so the creation of choice fields is skipped. """ self._product = kwargs.pop("product", None) self._to_cart = kwargs.pop("to_cart") super(AddProductForm, self).__init__(*args, **kwargs) # Adding from the wishlist with a sku, bail out. if args[0] is not None and args[0].get("sku", None): return # Adding from the product page, remove the sku field # and build the choice fields for the variations. del self.fields["sku"] option_fields = ProductVariation.option_fields() if not option_fields: return option_names, option_labels = list( zip(*[(f.name, f.verbose_name) for f in option_fields])) option_values = list( zip(*self._product.variations.filter( unit_price__isnull=False).values_list(*option_names))) if option_values: for i, name in enumerate(option_names): values = [_f for _f in set(option_values[i]) if _f] if values: field = forms.ChoiceField(label=option_labels[i], choices=make_choices(values)) self.fields[name] = field if self._product.content_model == 'reservableproduct': # ReservableProduct needs from/to dates and does not need quantity self.fields["from_date"] = forms.DateField( input_formats=["%d.%m.%Y"], widget=forms.HiddenInput()) self.fields["to_date"] = forms.DateField( input_formats=["%d.%m.%Y"], widget=forms.HiddenInput()) self.fields["quantity"] = forms.IntegerField( min_value=1, initial=1, widget=forms.HiddenInput())
def test_cart(self): """ Test the cart object and cart add/remove forms. """ product_options = ProductOption.objects.as_fields() self._product.variations.all().delete() self._product.variations.create_from_options(product_options) price = Decimal("20") num_in_stock = 5 variation = self._product.variations.all()[0] variation.unit_price = price variation.num_in_stock = num_in_stock * 2 variation.save() # Test initial cart. cart = Cart.objects.from_request(self.client) self.assertFalse(cart.has_items()) self.assertEqual(cart.total_quantity(), 0) self.assertEqual(cart.total_price(), Decimal("0")) # Add quantity and check stock levels / cart totals. data = dict(zip([field.name for field in ProductVariation.option_fields()], variation.options())) data["quantity"] = num_in_stock self.client.post(self._product.get_absolute_url(), data) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertTrue(variation.has_stock(num_in_stock)) self.assertFalse(variation.has_stock(num_in_stock * 2)) self.assertTrue(cart.has_items()) self.assertEqual(cart.total_quantity(), num_in_stock) self.assertEqual(cart.total_price(), price * num_in_stock) # Add remaining quantity and check again. self.client.post(self._product.get_absolute_url(), data) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertFalse(variation.has_stock()) self.assertTrue(cart.has_items()) self.assertEqual(cart.total_quantity(), num_in_stock * 2) self.assertEqual(cart.total_price(), price * num_in_stock * 2) # Remove from cart. for item in cart: self.client.post(reverse("shop_cart"), {"item_id": item.id}) cart = Cart.objects.from_request(self.client) variation = self._product.variations.all()[0] self.assertTrue(variation.has_stock(num_in_stock * 2)) self.assertFalse(cart.has_items()) self.assertEqual(cart.total_quantity(), 0) self.assertEqual(cart.total_price(), Decimal("0"))
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_discount(request) recalculate_billship_tax(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 __init__(self, *args, **kwargs): """ Handles adding a variation to the cart or wishlist. When adding from the product page, the product is provided from the view and a set of choice fields for all the product options for this product's variations are added to the form. When the form is validated, the selected options are used to determine the chosen variation. A ``to_cart`` boolean keyword arg is also given specifying whether the product is being added to a cart or wishlist. If a product is being added to the cart, then its stock level is also validated. When adding to the cart from the wishlist page, a sku is given for the variation, so the creation of choice fields is skipped. """ self._product = kwargs.pop("product", None) self._to_cart = kwargs.pop("to_cart") super(AddProductForm, self).__init__(*args, **kwargs) # Adding from the wishlist with a sku, bail out. if args[0] is not None and args[0].get("sku", None): return # Adding from the product page, remove the sku field # and build the choice fields for the variations. del self.fields["sku"] option_fields = ProductVariation.option_fields() if not option_fields: return option_names, option_labels = list(zip(*[(f.name, f.verbose_name) for f in option_fields])) option_values = list(zip(*self._product.variations.filter( unit_price__isnull=False).values_list(*option_names))) if option_values: for i, name in enumerate(option_names): values = [_f for _f in set(option_values[i]) if _f] if values: field = forms.ChoiceField(label=option_labels[i], choices=make_choices(values)) self.fields[name] = field if self._product.content_model == 'reservableproduct': # ReservableProduct needs from/to dates and does not need quantity self.fields["from_date"] = forms.DateField(input_formats=["%d.%m.%Y"], widget=forms.HiddenInput()) self.fields["to_date"] = forms.DateField(input_formats=["%d.%m.%Y"], widget=forms.HiddenInput()) self.fields["quantity"] = forms.IntegerField(min_value=1, initial=1, widget=forms.HiddenInput())
def __init__(self, *args, **kwargs): """ Handles adding a variation to the cart or wishlist. When adding from the product page, the product is provided from the view and a set of choice fields for all the product options for this product's variations are added to the form. When the form is validated, the selected options are used to determine the chosen variation. A ``to_cart`` boolean keyword arg is also given specifying whether the product is being added to a cart or wishlist. If a product is being added to the cart, then its stock level is also validated. When adding to the cart from the wishlist page, a sku is given for the variation, so the creation of choice fields is skipped. """ self._product = kwargs.pop("product", None) self._to_cart = kwargs.pop("to_cart") super(AddProductForm, self).__init__(*args, **kwargs) # Adding from the wishlist with a sku, bail out. if args[0] is not None and args[0].get("sku", None): return # Adding from the product page, remove the sku field # and build the choice fields for the variations. del self.fields["sku"] option_fields = ProductVariation.option_fields() if not option_fields: return option_names, option_labels = zip(*[(f.name, f.verbose_name) for f in option_fields]) option_values = zip(*self._product.variations.filter( unit_price__isnull=False).values_list(*option_names)) if option_values: for i, name in enumerate(option_names): values = list(option_values[i]) try: values.remove(None) except ValueError: pass if values: field = forms.ChoiceField(label=option_labels[i], choices=make_choices(values)) self.fields[name] = field
def __init__(self, *args, **kwargs): """ Create each ChoiceField for selecting from the product's variations. """ self._to_cart = kwargs.pop("to_cart", True) super(AddProductForm, self).__init__(*args, **kwargs) option_names, option_labels = zip(*[(f.name, f.verbose_name) for f in ProductVariation.option_fields()]) option_values = zip(*product.variations.filter( unit_price__isnull=False).values_list(*option_names)) if option_values: for i, name in enumerate(option_names): values = filter(None, set(option_values[i])) if values: field = forms.ChoiceField(label=option_labels[i], choices=make_choices(values)) self.fields[name] = field
def product(request, prod, template="shop/product.html", form_class=AddProductForm): #pdb.set_trace() fields = [f.name for f in ProductVariation.option_fields()] variations = prod.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 = {} initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=prod, initial=initial_data, to_cart=to_cart) context = { "variations": variations, "add_product_form": add_product_form } return context
def cart_item_view(request, template="shop/product.html", form_class=AddProductForm, extra_content=None, cart_id="", item_id=""): cart = Cart.objects.filter(id=cart_id).first() item = next(item for item in cart.items.iterator() if item.id == int(item_id)) published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=item.url.split('/')[-1]) 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 ]) variation = ProductVariation.objects.filter(sku=item.sku).first() v_json = dict([(f, getattr(variation, f)) for f in fields + ["sku", "image_id"] if getattr(variation, f) is not None]) initial_data = dict(quantity=item.quantity, **v_json) initial_data['embroidery_type'] = item.personalization.embroidery_type initial_data['value'] = item.personalization.value add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=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]), "add_product_form": add_product_form, "item": item } return render(request, template, context)
def parse_description(value, autoescape=True): """ Split product description to title and options to allow different styling. Returns html with title and options in two lines with different classes: 'title' and 'options'. """ option_fields = ProductVariation.option_fields() if option_fields: first_option_label = option_fields[0].verbose_name m = re.match(ur"(.*\w*)\s(%s.*)$" % first_option_label, value, re.I | re.U) if m: title = m.group(1) options = m.group(2) if autoescape: esc = conditional_escape else: esc = lambda x: x return mark_safe( "<span class='title'>%s</span><br><span class='options'>%s</span>" % (esc(title), esc(options))) else: return value
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) to_cart = request.method == "POST" and request.POST.get("add_wishlist") is None add_product_form = AddProductForm(request.POST or None, product=product, initial={"quantity": 1}, 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_discount(request) info(request, _("Item added to cart")) return HttpResponseRedirect(reverse("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 = HttpResponseRedirect(reverse("shop_wishlist")) set_cookie(response, "wishlist", ",".join(skus)) return response fields = [f.name for f in ProductVariation.option_fields()] fields += ["sku", "image_id"] variations = product.variations.all() variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields]) for v in variations]) context = { "product": product, "images": product.images.all(), "variations": variations, "variations_json": variations_json, "has_available_variations": any([v.has_price() for v in variations]), "related": product.related_products.published(for_user=request.user), "add_product_form": add_product_form, } return render_to_response(template, context, RequestContext(request))
def product(request, prod, template="shop/product.html", form_class=AddProductForm): #pdb.set_trace() fields = [f.name for f in ProductVariation.option_fields()] variations = prod.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 = {} initial_data["quantity"] = 1 add_product_form = form_class(request.POST or None, product=prod, initial=initial_data, to_cart=to_cart) context = {"variations": variations, "add_product_form": add_product_form} return context
def test_order(self): """ Test that a completed order contains cart items and that they're removed from stock. """ # Get a variation. self._product.variations.all().delete() self._product.variations.create_from_options(self._options) variation = self._product.variations.all()[0] variation.unit_price = TEST_PRICE variation.num_in_stock = TEST_STOCK * 2 variation.save() # Add to cart. field_names = [f.name for f in ProductVariation.option_fields()] data = dict(zip(field_names, variation.options())) data["quantity"] = TEST_STOCK self.client.post(self._product.get_absolute_url(), data) cart = Cart.objects.from_request(self.client) # Post order. data = {"step": len(CHECKOUT_STEPS)} self.client.post(reverse("shop_checkout"), data) try: order = Order.objects.from_request(self.client) except Order.DoesNotExist: self.fail("Couldn't create an order") items = order.items.all() variation = self._product.variations.all()[0] self.assertEqual(cart.total_quantity(), 0) self.assertEqual(len(items), 1) self.assertEqual(items[0].sku, variation.sku) self.assertEqual(items[0].quantity, TEST_STOCK) self.assertEqual(variation.num_in_stock, TEST_STOCK) self.assertEqual(order.item_total, TEST_PRICE * TEST_STOCK)
def handle_wishlist(request, slug, form_class=AddProductForm): if request.method == 'POST' and request.is_ajax(): published_products = Product.objects.published(for_user=request.user) product = get_object_or_404(published_products, slug=slug) initial_data = {} variations = product.variations.all() fields = [f.name for f in ProductVariation.option_fields()] 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=False) if add_product_form.is_valid(): skus = request.wishlist sku = add_product_form.variation.sku if sku not in skus: skus.append(sku) messages.info(request, _("Item added to wishlist")) response = render(request,'messages.html') set_cookie(response, "wishlist", ",".join(skus)) return response return HttpResponse(json.dumps(add_product_form.errors), content_type="application/json") return HttpResponse('not post')
TabularDynamicInlineAdmin, BaseTranslationModelAdmin) from mezzanine.pages.admin import PageAdmin from cartridge.shop.fields import MoneyField from cartridge.shop.forms import ProductAdminForm, ProductVariationAdminForm from cartridge.shop.forms import ProductVariationAdminFormset from cartridge.shop.forms import DiscountAdminForm, ImageWidget, MoneyWidget from cartridge.shop.models import Category, Product, ProductImage from cartridge.shop.models import ProductVariation, ProductOption, Order from cartridge.shop.models import OrderItem, Sale, DiscountCode from cartridge.shop.views import HAS_PDF # Lists of field names. option_fields = [f.name for f in ProductVariation.option_fields()] _flds = lambda s: [f.name for f in Order._meta.fields if f.name.startswith(s)] billing_fields = _flds("billing_detail") shipping_fields = _flds("shipping_detail") ################ # CATEGORIES # ################ # Categories fieldsets are extended from Page fieldsets, since # categories are a Mezzanine Page type. category_fieldsets = deepcopy(PageAdmin.fieldsets) category_fieldsets[0][1]["fields"][3:3] = ["content", "products"] category_fieldsets += ((_("Product filters"), { "fields": ("sale", ("price_min", "price_max"), "combined"),
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 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 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 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))
from mezzanine.conf import settings from mezzanine.core.admin import (DisplayableAdmin, TabularDynamicInlineAdmin, BaseTranslationModelAdmin) from mezzanine.pages.admin import PageAdmin from cartridge.shop.fields import MoneyField from cartridge.shop.forms import ProductAdminForm, ProductVariationAdminForm from cartridge.shop.forms import ProductVariationAdminFormset from cartridge.shop.forms import DiscountAdminForm, ImageWidget, MoneyWidget from cartridge.shop.models import Category, Product, ProductImage from cartridge.shop.models import ProductVariation, ProductOption, Order from cartridge.shop.models import OrderItem, Sale, DiscountCode from cartridge.shop.views import HAS_PDF # Lists of field names. option_fields = [f.name for f in ProductVariation.option_fields()] _flds = lambda s: [f.name for f in Order._meta.fields if f.name.startswith(s)] billing_fields = _flds("billing_detail") shipping_fields = _flds("shipping_detail") ################ # CATEGORIES # ################ # Categories fieldsets are extended from Page fieldsets, since # categories are a Mezzanine Page type. category_fieldsets = deepcopy(PageAdmin.fieldsets) category_fieldsets[0][1]["fields"][3:3] = ["content", "products"] category_fieldsets += (( _("Product filters"), {
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"): """ 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. """ 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 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 product(request, slug, template="shop/product.html", form_class=AddProductForm, extra_context=None): print "MODIFIED DEF PRODUCT" """ 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"] data = add_product_form.cleaned_data data = dict(data) request.session['quantity'] = json.dumps(data['quantity']) request.session['fabrics'] = str(data['fabrics']) request.session['sku'] = str(add_product_form.variation.sku) #checking what data/fields are stored in request.session before redirecting to other steps # for field in request.session.iteritems(): # print "FIRST FIELD ITEM IS " + str(field) #redirect to step 2. "tailorSelect" calls the next view and is configured in the monkeyPatch/urls.py return HttpResponseRedirect("tailorSelect") 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 = [] ### # fabrics = product.fabrics.all() 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 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)