def delete_cart_item(request, cart_item_id): """Deletes the cart item with the given id. """ lfs_get_object_or_404(CartItem, pk=cart_item_id).delete() cart = cart_utils.get_cart(request) cart_changed.send(cart, request=request) return HttpResponse(cart_inline(request))
def add_accessory_to_cart(request, product_id, quantity=1): """Adds an accessory to the cart and updates the added-to-cart view. """ try: quantity = float(quantity) except TypeError: quantity = 1 product = lfs_get_object_or_404(Product, pk=product_id) session_cart_items = request.session.get("cart_items", []) cart = cart_utils.get_cart(request) # Add product to cart try: cart_item = CartItem.objects.get(cart=cart, product=product) except ObjectDoesNotExist: cart_item = CartItem.objects.create(cart=cart, product=product, amount=quantity) session_cart_items.append(cart_item) else: cart_item.amount += quantity cart_item.save() if cart_item not in session_cart_items: session_cart_items.append(cart_item) else: # Update save cart item within session for session_cart_item in session_cart_items: if cart_item.product == session_cart_item.product: session_cart_item.amount += quantity request.session["cart_items"] = session_cart_items cart_changed.send(cart, request=request) return HttpResponse(added_to_cart_items(request))
def category_categories(request, slug, start=0, template_name="lfs/catalog/categories/category/default.html"): """Displays the child categories of the category with passed slug. This view is called if the user chooses a template that is situated in settings.CATEGORY_PATH ". """ cache_key = "%s-category-categories-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, slug) result = cache.get(cache_key) if result is not None: return result category = lfs_get_object_or_404(Category, slug=slug) format_info = category.get_format_info() amount_of_cols = format_info["category_cols"] categories = [] row = [] for i, children in enumerate(category.get_children()): row.append(children) if (i + 1) % amount_of_cols == 0: categories.append(row) row = [] if len(row) > 0: categories.append(row) render_template = category.get_template_name() if render_template != None: template_name = render_template result = render_to_string(template_name, RequestContext(request, {"category": category, "categories": categories})) cache.set(cache_key, result) return result
def get(self, request, id): """ Handle GET request """ obj = lfs_get_object_or_404(self.model_klass, pk=id) form = self.form_klass(instance=obj) return self.render_to_response(form)
def product_form_dispatcher(request): """Dispatches to the added-to-cart view or to the selected variant. This is needed as the product form can have several submit buttons: - The add-to-cart button - The switch to the selected variant button (only in the case the variants of of the product are displayed as select box. This may change in future, when the switch may made with an ajax request.) """ if request.REQUEST.get("add-to-cart") is not None: return add_to_cart(request) else: product_id = request.POST.get("product_id") product = lfs_get_object_or_404(Product, pk=product_id) options = lfs_utils.parse_properties(request) variant = product.get_variant(options) if variant is None: variant = product.get_default_variant() return lfs.core.utils.set_message_cookie( variant.get_absolute_url(), msg=_(u"The choosen combination of properties is not deliverable.") ) return HttpResponseRedirect(variant.get_absolute_url())
def manage_digital_products(request, product_id, as_string=False, template_name="lfs_downloads/manage_digital_products.html"): product = lfs_get_object_or_404(Product, pk=product_id) digiproducts = DigitalAsset.objects.filter(product=product).all() donation_mode = DigitalAsset.objects.filter(product=product, donation_mode=True).all() minimum_price = '1.0' suggested_price = '10.0' if len(digiproducts): minimum_price = digiproducts[0].minimum_price suggested_price = digiproducts[0].suggested_price result = render_to_string(template_name,RequestContext(request, { "product": product, "digiproducts": digiproducts, "has_digiproducts": len(digiproducts), "donation_mode": len(donation_mode), 'minimum_price': minimum_price, 'suggested_price': suggested_price, })) if as_string: return result else: result = simplejson.dumps({ "html_data": result, "message": _(u"New attachment."), }, cls=LazyEncoder) return HttpResponse(result)
def customer_inline(request, customer_id, template_name="manage/customer/customer_inline.html"): """Displays customer with provided customer id. """ customer_filters = request.session.get("customer-filters", {}) customer = lfs_get_object_or_404(Customer, pk=customer_id) orders = Order.objects.filter(session=customer.session) try: cart = Cart.objects.get(session=customer.session) cart_price = cart.get_price_gross(request) except Cart.DoesNotExist: cart = None cart_price = None else: # Shipping selected_shipping_method = lfs.shipping.utils.get_selected_shipping_method(request) shipping_costs = lfs.shipping.utils.get_shipping_costs(request, selected_shipping_method) # Payment selected_payment_method = lfs.payment.utils.get_selected_payment_method(request) payment_costs = lfs.payment.utils.get_payment_costs(request, selected_payment_method) cart_price = cart.get_price_gross(request) + shipping_costs["price"] + payment_costs["price"] return render_to_string(template_name, RequestContext(request, { "customer": customer, "orders": orders, "cart": cart, "cart_price": cart_price, }))
def manage_product(request, product_id, template_name="manage/product/product.html"): """Displays the whole manage/edit form for the product with the passed id. """ # NOTE: For any reason the script from swfupload (see product/images.html) # calls this method (I have no idea how and why). It calls it without a # product id so we have to take care of it here as a workaround. if not product_id: return HttpResponse("") product = lfs_get_object_or_404(Product, pk=product_id) products = _get_filtered_products(request) paginator = Paginator(products, 20) page = paginator.page(request.REQUEST.get("page", 1)) try: product = Product.objects.get(pk=product_id) except Exception: return HttpResponse("") return render_to_response(template_name, RequestContext(request, { "product" : product, "product_filters" : product_filters_inline(request, page, paginator, product_id), "pages_inline" : pages_inline(request, page, paginator), "product_data" : product_data_form(request, product_id), "images" : manage_images(request, product_id, as_string=True), "selectable_products" : selectable_products_inline(request, page, paginator, product.id), "seo" : manage_seo(request, product_id), "stock" : stock(request, product_id), "portlets" : portlets_inline(request, product), "properties" : manage_properties(request, product_id), "form" : ProductSubTypeForm(instance=product) }))
def as_html(self, request, position): """Renders the criterion as html in order to be displayed within several forms. """ shop = lfs_get_object_or_404(Shop, pk=1) countries = [] for country in shop.countries.all(): if country in self.countries.all(): selected = True else: selected = False countries.append({ "id" : country.id, "name" : country.name, "selected" : selected, }) return render_to_string("manage/criteria/country_criterion.html", RequestContext(request, { "id" : "ex%s" % self.id, "operator" : self.operator, "value" : self.value, "position" : position, "countries" : countries, }))
def product_view(request, slug, template_name="lfs/catalog/product_base.html"): """Main view to display a product. """ product = lfs_get_object_or_404(Product, slug=slug) if (request.user.is_superuser or product.is_active()) == False: raise Http404() # Store recent products for later use recent = request.session.get("RECENT_PRODUCTS", []) if slug in recent: recent.remove(slug) recent.insert(0, slug) if len(recent) > settings.LFS_RECENT_PRODUCTS_LIMIT: recent = recent[:settings.LFS_RECENT_PRODUCTS_LIMIT + 1] request.session["RECENT_PRODUCTS"] = recent if product.is_variant(): variant_canonical = product.parent.get_variant_for_category(request) else: variant_canonical = product result = render_to_response(template_name, RequestContext(request, { "product_inline": product_inline(request, product), "variant_canonical": variant_canonical, "product": product, })) return result
def manage_categories(request, product_id, template_name="manage/product/categories.html"): """Displays the manage category view. """ product = lfs_get_object_or_404(Product, pk=product_id) product_category_ids = [p.id for p in product.get_categories()] categories = [] for category in Category.objects.filter(parent=None): children = children_categories(request, category, product_category_ids) categories.append( { "id": category.id, "slug": category.slug, "name": category.name, "url": category.get_absolute_url(), "checked": category.id in product_category_ids, "children": children, } ) result = render_to_string(template_name, RequestContext(request, {"product": product, "categories": categories})) return HttpResponse(result)
def _get_related_products_by_tags(product_id, num=None): """Returns a dict with related products by tags. This is just a thin wrapper for the get_related method of the TaggedItem manager of the tagging product in order to provide caching. From the tagging product's doc string (mutatis mutantis): Returns a list of products which share tags with the product with passed id ordered by the number of shared tags in descending order. See there for more. """ # Try to get it out of cache cache_key = "related-products-by-tags-%s" % product_id related_products = cache.get(cache_key) if related_products is not None: return {"related_products" : related_products} # Create related products product = lfs_get_object_or_404(Product, pk=product_id) related_products = TaggedItem.objects.get_related(product, Product, num) # Save related_products within cache cache.set(cache_key, related_products) return {"related_products" : related_products}
def cart_inline(request, cart_id, template_name="manage/cart/cart_inline.html"): """Displays cart with provided cart id. """ cart = lfs_get_object_or_404(Cart, pk=cart_id) total = 0 for item in cart.get_items(): total += item.get_price_gross(request) try: if cart.user: customer = Customer.objects.get(user=cart.user) else: customer = Customer.objects.get(session=cart.session) except Customer.DoesNotExist: customer = None cart_filters = request.session.get("cart-filters", {}) return render_to_string(template_name, RequestContext(request, { "cart": cart, "customer": customer, "total": total, "start": cart_filters.get("start", ""), "end": cart_filters.get("end", ""), }))
def customer_inline(request, customer_id, as_string=False, template_name="manage/customer/customer_inline.html"): """Displays customer with provided customer id. """ customer_filters = request.session.get("customer-filters", {}) customer = lfs_get_object_or_404(Customer, pk=customer_id) orders = Order.objects.filter(session=customer.session) try: cart = Cart.objects.get(session=customer.session) cart_price = lfs.cart.utils.get_cart_price(request, cart, total=True) except Cart.DoesNotExist: cart = None cart_price = None result = render_to_string(template_name, RequestContext(request, { "customer" : customer, "orders" : orders, "cart" : cart, "cart_price" : cart_price, "name" : customer_filters.get("name", ""), })) if as_string: return result else: html = (("#customer-inline", result),) result = simplejson.dumps({ "html" : html, }, cls = LazyEncoder) return HttpResponse(result)
def add_accessory_to_cart(request, product_id, quantity=1): """ Adds the product with passed product_id as an accessory to the cart and updates the added-to-cart view. """ product = lfs_get_object_or_404(Product, pk=product_id) # for product with variants add default variant if product.is_product_with_variants(): variant = product.get_default_variant() if variant: product = variant else: return HttpResponse(added_to_cart_items(request)) quantity = product.get_clean_quantity_value(quantity) session_cart_items = request.session.get("cart_items", []) cart = cart_utils.get_cart(request) cart_item = cart.add(product=product, amount=quantity) # Update session if cart_item not in session_cart_items: session_cart_items.append(cart_item) else: for session_cart_item in session_cart_items: if cart_item.product == session_cart_item.product: session_cart_item.amount += quantity request.session["cart_items"] = session_cart_items cart_changed.send(cart, request=request) return HttpResponse(added_to_cart_items(request))
def update_attachments(request, product_id): """Saves/deletes attachments with given ids (passed by request body). """ product = lfs_get_object_or_404(Product, pk=product_id) action = request.POST.get("action") message = _(u"Attachment has been updated.") if action == "delete": message = _(u"Attachment has been deleted.") for key in request.POST.keys(): if key.startswith("delete-"): try: id = key.split("-")[1] attachment = ProductAttachment.objects.get(pk=id).delete() except (IndexError, ObjectDoesNotExist): pass elif action == "update": message = _(u"Attachment has been updated.") for attachment in product.attachments.all(): attachment.title = request.POST.get("title-%s" % attachment.id) attachment.position = request.POST.get("position-%s" % attachment.id) attachment.description = request.POST.get("description-%s" % attachment.id) attachment.save() # Refresh positions for i, attachment in enumerate(product.attachments.all()): attachment.position = (i + 1) * 10 attachment.save() product_changed.send(product, request=request) html = [["#attachments", manage_attachments(request, product_id, as_string=True)]] result = simplejson.dumps({"html": html, "message": message}, cls=LazyEncoder) return HttpResponse(result, mimetype="application/json")
def selectable_customers_inline(request, customer_id, template_name="manage/customer/selectable_customers_inline.html"): """Display selectable customers. """ AMOUNT = 30 customer = lfs_get_object_or_404(Customer, pk=customer_id) customer_filters = request.session.get("customer-filters", {}) customers = _get_filtered_customers(request, customer_filters) # Display only customers with at least one order temp = [] for c in customers: orders = Order.objects.filter(session=c.session) if (c.user) or (len(orders) > 0): temp.append(c) page = get_current_page(request, temp, customer, AMOUNT) paginator = Paginator(temp, AMOUNT) try: page = paginator.page(page) except EmptyPage: page = paginator.page(1) return render_to_string(template_name, RequestContext(request, { "paginator": paginator, "page": page, "customer_id": int(customer_id), }))
def get_parent_for_portlets(self): """Returns the parent for parents. """ if self.id == 1: return get_default_shop() else: return lfs_get_object_or_404(Page, pk=1)
def get_pay_link(self): shop = lfs_get_object_or_404(Shop, pk=1) current_site = Site.objects.get(id=settings.SITE_ID) conv = locale.localeconv() default_currency = conv['int_curr_symbol'] info = { "cmd": "_xclick", "upload": "1", "business": settings.PAYPAL_RECEIVER_EMAIL, "currency_code": default_currency, "notify_url": "http://" + current_site.domain + reverse('paypal-ipn'), "return": "http://" + current_site.domain + reverse('paypal-pdt'), "first_name": self.order.invoice_address.firstname, "last_name": self.order.invoice_address.lastname, "address1": self.order.invoice_address.line1, "address2": self.order.invoice_address.line2, "city": self.order.invoice_address.city, "state": self.order.invoice_address.state, "zip": self.order.invoice_address.zip_code, "no_shipping": "1", "custom": self.order.uuid, "invoice": self.order.uuid, "item_name": shop.shop_owner, "amount": "%.2f" % (self.order.price - self.order.tax), "tax": "%.2f" % self.order.tax, } parameters = "&".join(["%s=%s" % (k, v) for (k, v) in info.items()]) if getattr(settings, 'PAYPAL_DEBUG', settings.DEBUG): url = SANDBOX_POSTBACK_ENDPOINT + "?" + parameters else: url = POSTBACK_ENDPOINT + "?" + parameters return url
def update_product_values(request, property_group_id): """Updates product property values. """ property_group = lfs_get_object_or_404(PropertyGroup, pk=property_group_id) product_ids = request.POST.getlist("product-id") products = Product.objects.filter(pk__in=product_ids) for product in products: for property in property_group.properties.all(): value = request.POST.get("property-%s-%s" % (product.id, property.id), "") if value != "": try: ppv = ProductPropertyValue.objects.get(property = property, product=product) except ProductPropertyValue.DoesNotExist: ProductPropertyValue.objects.create(property = property, product=product, value=value) else: ppv.value = value ppv.save() result = simplejson.dumps({ "html" : product_values(request, property_group_id), "message" : _(u"Product Values have been saved.") }, cls=LazyEncoder); return HttpResponse(result)
def edit_seo(request, category_id, template_name="manage/category/seo.html"): """Displays an edit form for category seo fields and saves the entered values. If it is called by an ajax request it returns the result and a status message as json. This is used as a part of the whole category form. """ category = lfs_get_object_or_404(Category, pk=category_id) if request.method == "POST": form = SEOForm(instance=category, data=request.POST) if form.is_valid(): form.save() message = _(u"SEO data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = SEOForm(instance=category) seo_html = render_to_string(template_name, RequestContext(request, { "category": category, "form": form, })) if request.is_ajax(): return HttpResponse(simplejson.dumps({ "seo": seo_html, "message": message, }, cls=LazyEncoder)) else: return seo_html
def order_inline(request, order_id, as_string=False, template_name="manage/order/order_inline.html"): """ """ order_filters = request.session.get("order-filters", {}) order = lfs_get_object_or_404(Order, pk=order_id) states = [] state_id = order_filters.get("state") for state in lfs.order.settings.ORDER_STATES: states.append({ "id" : state[0], "name" : state[1], "selected_filter" : state_id == str(state[0]), "selected_order" : order.state == state[0], }) result = render_to_string(template_name, RequestContext(request, { "current_order" : order, "start" : order_filters.get("start", ""), "end" : order_filters.get("end", ""), "name" : order_filters.get("name", ""), "states" : states, })) if as_string: return result else: return HttpResponse(result)
def add_accessory_to_cart(request, product_id, quantity=1): """ Adds the product with passed product_id as an accessory to the cart and updates the added-to-cart view. """ try: quantity = float(quantity) except TypeError: quantity = 1 product = lfs_get_object_or_404(Product, pk=product_id) session_cart_items = request.session.get("cart_items", []) cart = cart_utils.get_cart(request) cart_item = cart.add(product=product, amount=quantity) # Update session if cart_item not in session_cart_items: session_cart_items.append(cart_item) else: for session_cart_item in session_cart_items: if cart_item.product == session_cart_item.product: session_cart_item.amount += quantity request.session["cart_items"] = session_cart_items cart_changed.send(cart, request=request) return HttpResponse(added_to_cart_items(request))
def category_view(request, category_id, template_name="manage/category/view.html"): """Displays the view data for the category with passed category id. This is used as a part of the whole category form. """ category = lfs_get_object_or_404(Category, pk=category_id) if request.method == "POST": form = ViewForm(instance=category, data=request.POST) if form.is_valid(): form.save() message = _(u"View data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = ViewForm(instance=category) view_html = render_to_string(template_name, RequestContext(request, { "category": category, "form": form, })) if request.is_ajax(): html = [["#view", view_html]] return HttpResponse(simplejson.dumps({ "html": html, "message": message, }, cls=LazyEncoder), mimetype='application/json') else: return view_html
def shop_view(request, template_name="lfs/shop/shop.html"): """Displays the shop. """ shop = lfs_get_object_or_404(Shop, pk=1) return render_to_response(template_name, RequestContext(request, { "shop": shop }))
def order_inline(request, order_id, template_name="manage/order/order_inline.html"): """Displays the details of an order. """ order_filters = request.session.get("order-filters", {}) order = lfs_get_object_or_404(Order, pk=order_id) states = [] state_id = order_filters.get("state") for state in lfs.order.settings.ORDER_STATES: states.append({ "id": state[0], "name": state[1], "selected_filter": state_id == str(state[0]), "selected_order": order.state == state[0], }) return render_to_string(template_name, RequestContext(request, { "current_order": order, "start": order_filters.get("start", ""), "end": order_filters.get("end", ""), "name": order_filters.get("name", ""), "states": states, "invoice_address": order.invoice_address.as_html(request, "invoice"), "shipping_address": order.shipping_address.as_html(request, "shipping"), }))
def manufacturer_view(request, manufacturer_id, template_name="manage/manufacturers/view.html"): """Displays the view data for the manufacturer with passed manufacturer id. This is used as a part of the whole category form. """ manufacturer = lfs_get_object_or_404(Manufacturer, pk=manufacturer_id) if request.method == "POST": form = ViewForm(instance=manufacturer, data=request.POST) if form.is_valid(): form.save() message = _(u"View data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = ViewForm(instance=manufacturer) view_html = render_to_string(template_name, RequestContext(request, { "manufacturer": manufacturer, "form": form, })) if request.is_ajax(): html = [["#view", view_html]] return HttpResponse(json.dumps({ "html": html, "message": message, }, cls=LazyEncoder), content_type='application/json') else: return view_html
def stock(request, product_id, template_name="manage/product/stock.html"): """ Displays and updates product's stock data. """ # prefix="stock" because <input name="length" doesn't seem to work with IE product = lfs_get_object_or_404(Product, pk=product_id) if request.method == "POST": form = ProductStockForm(prefix="stock", instance=product, data=request.POST) if form.is_valid(): form.save() message = _(u"Product stock data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = ProductStockForm(prefix="stock", instance=product) result = render_to_string(template_name, RequestContext(request, { "product": product, "form": form })) html = [["#stock", result]] if request.is_ajax(): result = simplejson.dumps({ "html": html, "message": message, }, cls=LazyEncoder) return HttpResponse(result) else: return result
def manage_product(request, product_id, template_name="manage/product/product.html"): """ Displays the whole manage/edit form for the product with the passed id. """ product = lfs_get_object_or_404(Product, pk=product_id) products = _get_filtered_products_for_product_view(request) paginator = Paginator(products, 25) temp = product.parent if product.is_variant() else product page = get_current_page(request, products, temp, 25) try: page = paginator.page(page) except EmptyPage: page = paginator.page(1) return render_to_response(template_name, RequestContext(request, { "product": product, "product_filters": product_filters_inline(request, page, paginator, product_id), "pages_inline": pages_inline(request, page, paginator, product_id), "product_data": product_data_form(request, product_id), "images": manage_images(request, product_id, as_string=True), "attachments": manage_attachments(request, product_id, as_string=True), "selectable_products": selectable_products_inline(request, page, paginator, product.id), "seo": SEOView(Product, form_klass=SEOForm, template_name='manage/product/seo.html').render(request, product), "stock": stock(request, product_id), "portlets": portlets_inline(request, product), "properties": manage_properties(request, product_id), "form": ProductSubTypeForm(instance=product), "name_filter_value": request.session.get("product_filters", {}).get("product_name", ""), }))
def category_view(request, slug, template_name="lfs/catalog/category_base.html"): """ """ start = request.REQUEST.get("start", 1) category = lfs_get_object_or_404(Category, slug=slug) if category.get_content() == CONTENT_PRODUCTS: inline_dict = category_products(request, slug, start) else: inline_dict = category_categories(request, slug) inline = inline_dict['html'] pagination_data = inline_dict['pagination_data'] # Set last visited category for later use, e.g. Display breadcrumbs, # selected menu points, etc. request.session["last_category"] = category if "last_manufacturer" in request.session: del(request.session["last_manufacturer"]) # TODO: Factor top_category out to a inclusion tag, so that people can # omit if they don't need it. return render_to_response(template_name, RequestContext(request, { "category": category, "category_inline": inline, "top_category": lfs.catalog.utils.get_current_top_category(request, category), "pagination": request.REQUEST.get("start", 0), 'pagination_data': pagination_data }))
def order_inline(request, order_id, template_name="manage/order/order_inline.html"): """Displays the details of an order. """ order_filters = request.session.get("order-filters", {}) order = lfs_get_object_or_404(Order, pk=order_id) states = [] state_id = order_filters.get("state") for state in lfs.order.settings.ORDER_STATES: states.append({ "id": state[0], "name": state[1], "selected_filter": state_id == str(state[0]), "selected_order": order.state == state[0], }) return render_to_string(template_name, RequestContext(request, { "current_order": order, "start": order_filters.get("start", ""), "end": order_filters.get("end", ""), "name": order_filters.get("name", ""), "states": states, }))
def test_totals_1(self): """Add a product without quantity to cart (implicit 1) """ rf = RequestFactory() request = rf.post("/", {"product_id": self.p1.id}) request.session = self.session request.user = self.user # Added product_1 to cart add_to_cart(request) response = added_to_cart_items(request) # Check we are using german locale shop = lfs_get_object_or_404(Shop, pk=1) self.assertEqual(shop.default_locale, 'en_US.UTF-8') # need to test for two versions of currency output (Mac and Ubuntu differ) self.failIf(response.find(u"Total: $10.00") == -1) # Added product_1 to cart again add_to_cart(request) response = added_to_cart_items(request) self.failIf(response.find(u"Total: $20.00") == -1)
def remove_products(request, discount_id): """Remove products from given property group with given property_group_id. """ discount = lfs_get_object_or_404(Discount, pk=discount_id) for temp_id in request.POST.keys(): if temp_id.startswith("product"): temp_id = temp_id.split("-")[1] product = Product.objects.get(pk=temp_id) discount.products.remove(product) html = [[ "#products-inline", products_inline(request, discount_id, as_string=True) ]] result = json.dumps( { "html": html, "message": _(u"Products have been removed.") }, cls=LazyEncoder) return HttpResponse(result, content_type='application/json')
def assign_products(request, group_id): """Assign products to given property group with given property_group_id. """ property_group = lfs_get_object_or_404(PropertyGroup, pk=group_id) for temp_id in request.POST.keys(): if temp_id.startswith("product"): temp_id = temp_id.split("-")[1] product = Product.objects.get(pk=temp_id) property_group.products.add(product) html = [[ "#products-inline", products_inline(request, group_id, as_string=True) ]] result = json.dumps( { "html": html, "message": _(u"Products have been assigned.") }, cls=LazyEncoder) return HttpResponse(result, content_type='application/json')
def product_view(request, slug, template_name="lfs/catalog/product_base.html"): """Main view to display a product. """ product = lfs_get_object_or_404(Product, slug=slug) if (request.user.is_superuser or product.is_active()) == False: raise Http404() # Store recent products for later use recent = request.session.get("RECENT_PRODUCTS", []) if slug in recent: recent.remove(slug) recent.insert(0, slug) if len(recent) > settings.LFS_RECENT_PRODUCTS_LIMIT: recent = recent[:settings.LFS_RECENT_PRODUCTS_LIMIT + 1] request.session["RECENT_PRODUCTS"] = recent result = render_to_response(template_name, RequestContext(request, { "product_inline": product_inline(request, product), "product": product, })) return result
def selectable_orders_inline(request, order_id, template_name="manage/order/selectable_orders_inline.html"): """Displays the selectable orders for the order view. (Used to switch quickly from one order to another.) """ order = lfs_get_object_or_404(Order, pk=order_id) order_filters = request.session.get("order-filters", {}) orders = _get_filtered_orders(order_filters) paginator = Paginator(orders, 20) try: page = int(request.REQUEST.get("page", 1)) except TypeError: page = 1 page = paginator.page(page) return render_to_string(template_name, RequestContext(request, { "current_order": order, "orders": orders, "paginator": paginator, "page": page, }))
def save_default_values_tab(request): """Saves the default value part """ shop = lfs_get_object_or_404(Shop, pk=1) form = ShopDefaultValuesForm(instance=shop, data=request.POST) if form.is_valid(): shop = form.save() shop_changed.send(shop) message = _(u"Shop default values have been saved.") else: message = _(u"Please correct the indicated errors.") result = simplejson.dumps( { "html": [["#default_values", default_values_tab(request, shop, form)]], "message": message }, cls=LazyEncoder) return HttpResponse(result)
def category_view(request, slug, template_name="lfs/catalog/category_base.html"): """ """ start = request.REQUEST.get("start", 1) category = lfs_get_object_or_404(Category, slug=slug) if category.get_content() == CONTENT_PRODUCTS: inline = category_products(request, slug, start) else: inline = category_categories(request, slug) # Set last visited category for later use, e.g. Display breadcrumbs, # selected menu points, etc. request.session["last_category"] = category if "last_manufacturer" in request.session: del(request.session["last_manufacturer"]) # TODO: Factor top_category out to a inclusion tag, so that people can # omit if they don't need it. return render_to_response(template_name, RequestContext(request, { "category": category, "category_inline": inline, "top_category": lfs.catalog.utils.get_current_top_category(request, category), }))
def order_view(request, order_id, template_name="manage/order/order.html"): """Displays the management interface for the order with passed order id. """ order_filters = request.session.get("order-filters", {}) order = lfs_get_object_or_404(Order, pk=order_id) states = [] state_id = order_filters.get("state") for state in lfs.order.settings.ORDER_STATES: states.append({ "id": state[0], "name": state[1], "selected_filter": state_id == str(state[0]), "selected_order": order.state == state[0], }) return render_to_response(template_name, RequestContext(request, { "order_inline": order_inline(request, order_id), "order_filters_inline": order_filters_inline(request, order_id), "selectable_orders": selectable_orders_inline(request, order_id), "current_order": order, "states": states, }))
def get_pay_link(self): shop = lfs_get_object_or_404(Shop, pk=1) current_site = Site.objects.get(id=settings.SITE_ID) conv = locale.localeconv() default_currency = conv['int_curr_symbol'] info = { "cmd": "_xclick", "upload": "1", "business": settings.PAYPAL_RECEIVER_EMAIL, "currency_code": default_currency, "notify_url": "http://" + current_site.domain + reverse('paypal-ipn'), "return": "http://" + current_site.domain + reverse('lfs_thank_you'), "first_name": self.order.invoice_address.firstname, "last_name": self.order.invoice_address.lastname, "address1": self.order.invoice_address.line1, "address2": self.order.invoice_address.line2, "city": self.order.invoice_address.city, "state": self.order.invoice_address.state, "zip": self.order.invoice_address.zip_code, "no_shipping": "1", "custom": self.order.uuid, "invoice": self.order.uuid, "item_name": shop.shop_owner, "amount": "%.2f" % (self.order.price - self.order.tax), "tax": "%.2f" % self.order.tax, } parameters = "&".join(["%s=%s" % (k, v) for (k, v) in info.items()]) if getattr(settings, 'PAYPAL_DEBUG', settings.DEBUG): url = SANDBOX_POSTBACK_ENDPOINT + "?" + parameters else: url = POSTBACK_ENDPOINT + "?" + parameters return url
def edit_seo(request, category_id, template_name="manage/category/seo.html"): """Displays an edit form for category seo fields and saves the entered values. If it is called by an ajax request it returns the result and a status message as json. This is used as a part of the whole category form. """ category = lfs_get_object_or_404(Category, pk=category_id) if request.method == "POST": form = SEOForm(instance=category, data=request.POST) if form.is_valid(): form.save() message = _(u"SEO data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = SEOForm(instance=category) seo_html = render_to_string( template_name, RequestContext(request, { "category": category, "form": form, })) if request.is_ajax(): return HttpResponse( simplejson.dumps({ "seo": seo_html, "message": message, }, cls=LazyEncoder)) else: return seo_html
def manage_attachments(request, product_id, as_string=False, template_name="manage/product/attachments.html"): """ """ product = lfs_get_object_or_404(Product, pk=product_id) result = render_to_string(template_name, RequestContext(request, { "product": product, })) if as_string: return result else: result = json.dumps( { "attachments": result, "message": _(u"Attachments have been added."), }, cls=LazyEncoder) return HttpResponse(result, content_type='application/json')
def manufacturer_view(request, manufacturer_id, template_name="manage/manufacturers/view.html"): """Displays the view data for the manufacturer with passed manufacturer id. This is used as a part of the whole category form. """ manufacturer = lfs_get_object_or_404(Manufacturer, pk=manufacturer_id) if request.method == "POST": form = ViewForm(instance=manufacturer, data=request.POST) if form.is_valid(): form.save() message = _(u"View data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = ViewForm(instance=manufacturer) view_html = render_to_string( template_name, RequestContext(request, { "manufacturer": manufacturer, "form": form, })) if request.is_ajax(): html = [["#view", view_html]] return HttpResponse( simplejson.dumps({ "html": html, "message": message, }, cls=LazyEncoder)) else: return view_html
def add_accessory_to_cart(request, product_id, quantity=1): """Adds an accessory to the cart and updates the added-to-cart view. """ try: quantity = float(quantity) except TypeError: quantity = 1 product = lfs_get_object_or_404(Product, pk=product_id) session_cart_items = request.session.get("cart_items", []) cart = cart_utils.get_cart(request) # Add product to cart try: cart_item = CartItem.objects.get(cart=cart, product=product) except ObjectDoesNotExist: cart_item = CartItem.objects.create( cart=cart, product=product, amount=quantity) session_cart_items.append(cart_item) else: cart_item.amount += quantity cart_item.save() if cart_item not in session_cart_items: session_cart_items.append(cart_item) else: # Update save cart item within session for session_cart_item in session_cart_items: if cart_item.product == session_cart_item.product: session_cart_item.amount += quantity request.session["cart_items"] = session_cart_items cart_changed.send(cart, request=request) return HttpResponse(added_to_cart_items(request))
def edit_product_data(request, product_id, template_name="manage/product/data.html"): """Edits the product with given. """ product = lfs_get_object_or_404(Product, pk=product_id) products = _get_filtered_products(request) paginator = Paginator(products, 20) page = paginator.page(request.REQUEST.get("page", 1)) if product.sub_type == VARIANT: form = VariantDataForm(instance=product, data=request.POST) else: form = ProductDataForm(instance=product, data=request.POST) if form.is_valid(): form.save() if product.sub_type == VARIANT: form = VariantDataForm(instance=product) else: form = ProductDataForm(instance=product) message = "Productdata has been saved." else: message = "Please correct the indicated errors." form_html = render_to_string(template_name, RequestContext(request, { "product" : product, "form" : form, })) result = simplejson.dumps({ "selectable_products" : selectable_products_inline(request, page, paginator, product_id), "form" : form_html, "message" : message, }) return HttpResponse(result)
def manage_shop(request, template_name="manage/shop/shop.html"): """Displays the form to manage shop data. """ shop = lfs_get_object_or_404(Shop, pk=1) if request.method == "POST": form = ShopForm(instance=shop, data=request.POST, files=request.FILES) if form.is_valid(): form.save() return lfs.core.utils.set_message_cookie( url=reverse("lfs_manage_shop"), msg=_(u"Shop data has been saved."), ) else: form = ShopForm(instance=shop) return render_to_response( template_name, RequestContext( request, { "shop": shop, "form": form, "default_values": default_values_part(request), "portlets": portlets_inline(request, shop), }))
def add_files(request, id): """Adds files to static block with passed id. """ static_block = lfs_get_object_or_404(StaticBlock, pk=id) if request.method == "POST": for file_content in request.FILES.getlist("file"): file = File(content=static_block, title=file_content.name) file.file.save(file_content.name, file_content, save=True) ctype = ContentType.objects.get_for_model(static_block) # Refresh positions for i, file in enumerate( File.objects.filter(content_type=ctype, content_id=static_block.id)): file.position = (i + 1) * 10 file.save() result = simplejson.dumps({ "name": file_content.name, "type": "image/jpeg", "size": "123456789" }) return HttpResponse(result)
def manage_images(request, product_id, as_string=False, template_name="manage/product/images.html"): """ """ product = lfs_get_object_or_404(Product, pk=product_id) result = render_to_string(template_name, RequestContext(request, { "product": product, })) if as_string: return result else: result = simplejson.dumps( { "images": result, "message": _(u"Images has been added."), }, cls=LazyEncoder) return HttpResponse(result, mimetype='application/json')
def category_view(request, category_id, template_name="manage/category/view.html"): """Displays the view data for the category with passed category id. This is used as a part of the whole category form. """ category = lfs_get_object_or_404(Category, pk=category_id) if request.method == "POST": form = ViewForm(instance=category, data=request.POST) if form.is_valid(): form.save() message = _(u"View data has been saved.") else: message = _(u"Please correct the indicated errors.") else: form = ViewForm(instance=category) view_html = render_to_string( template_name, RequestContext(request, { "category": category, "form": form, })) if request.is_ajax(): html = [["#view", view_html]] return HttpResponse(json.dumps({ "html": html, "message": message, }, cls=LazyEncoder), content_type='application/json') else: return view_html
def cart_inline(request, cart_id, as_string=False, template_name="manage/cart/cart_inline.html"): """Displays cart with provided cart id. """ cart = lfs_get_object_or_404(Cart, pk=cart_id) total = 0 for item in cart.items(): total += item.get_price_gross() try: if cart.user: customer = Customer.objects.get(user=cart.user) else: customer = Customer.objects.get(session=cart.session) except Customer.DoesNotExist: customer = None cart_filters = request.session.get("cart-filters", {}) result = render_to_string(template_name, RequestContext(request, { "cart" : cart, "customer" : customer, "total" : total, "start" : cart_filters.get("start", ""), "end" : cart_filters.get("end", ""), })) if as_string: return result else: html = (("#cart-inline", result),) result = simplejson.dumps({ "html" : html, }, cls = LazyEncoder) return HttpResponse(result)
def shop_view(request, template_name="lfs/shop/shop.html"): """Displays the shop. """ shop = lfs_get_object_or_404(Shop, pk=1) return render_to_response(template_name, RequestContext(request, {"shop": shop}))
def update_variants(request, product_id): """Updates/Deletes variants with passed ids (via request body) dependent on given action (also via request body). """ product = lfs_get_object_or_404(Product, pk=product_id) message = '' action = request.POST.get("action") if action == "delete": message = _(u"Variants have been deleted.") for key in request.POST.keys(): if key.startswith("delete-"): try: prop_id = key.split("-")[1] variant = Product.objects.get(pk=prop_id) except (IndexError, ObjectDoesNotExist): continue else: if product.default_variant == variant: product.default_variant = None product.save() variant.delete() elif action == "update": # TODO: change all of these to formsets or something that will allow for error hangling/messages message = _(u"Variants have been saved.") for key, value in request.POST.items(): if key.startswith("variant-"): prop_id = key.split("-")[1] try: variant = Product.objects.get(pk=prop_id) except ObjectDoesNotExist: continue else: for name in ("sku", "price"): value = request.POST.get("%s-%s" % (name, prop_id)) if value != "": if name == 'price': value = float(value) setattr(variant, name, value) # handle slug - ensure it is unique slug = request.POST.get("slug-%s" % prop_id) if variant.slug != slug: counter = 1 new_slug = slug while Product.objects.exclude(pk=variant.pk).filter( slug=new_slug).exists(): new_slug = '%s-%s' % (slug[:( 79 - len(str(counter)))], counter) counter += 1 variant.slug = new_slug # name variant.name = request.POST.get("name-%s" % prop_id) # active active = request.POST.get("active-%s" % prop_id) if active: variant.active = True else: variant.active = False # active attributes for name in ("active_price", "active_sku", "active_name"): value = request.POST.get("%s-%s" % (name, prop_id)) if value: setattr(variant, name, True) else: setattr(variant, name, False) # position position = request.POST.get("position-%s" % prop_id) try: variant.variant_position = int(position) except ValueError: variant.variant_position = 10 # default variant try: product.default_variant_id = int( request.POST.get("default_variant")) except TypeError: pass else: product.save() variant.save() elif key.startswith("property"): # properties are marshalled as: property-variant_id|property_id temp = key.split("-")[1] variant_id, property_id = temp.split("|") try: variant = Product.objects.get(pk=variant_id) except Product.DoesNotExist: continue prop = Property.objects.get(pk=property_id) ppv = None ppv_filterable = None try: ppv = ProductPropertyValue.objects.get( product=variant, property_id=property_id, type=PROPERTY_VALUE_TYPE_VARIANT) except ProductPropertyValue.DoesNotExist: pass if prop.filterable: try: ppv_filterable = ProductPropertyValue.objects.get( product=variant, property_id=property_id, type=PROPERTY_VALUE_TYPE_FILTER) except ProductPropertyValue.DoesNotExist: pass if value != '': if not ppv: ppv = ProductPropertyValue.objects.create( product=variant, property_id=property_id, type=PROPERTY_VALUE_TYPE_VARIANT, value=value) else: ppv.value = value ppv.save() if prop.filterable: if not ppv_filterable: ProductPropertyValue.objects.create( product=variant, property_id=property_id, value=value, type=PROPERTY_VALUE_TYPE_FILTER) else: ppv_filterable.value = value ppv_filterable.save() elif ppv: ppv.delete() if ppv_filterable: ppv_filterable.delete() # Refresh variant positions for i, variant in enumerate(product.variants.order_by("variant_position")): variant.variant_position = (i + 1) * 10 variant.save() # Send a signal to update cache product_changed.send(product) pid = product.get_parent().pk invalidate_cache_group_id('properties-%s' % pid) html = ( ("#variants", manage_variants(request, product_id, as_string=True)), ("#selectable-products-inline", _selectable_products_inline(request, product)), ) result = simplejson.dumps({ "html": html, "message": message, }, cls=LazyEncoder) return HttpResponse(result)
def products_inline(request, manufacturer_id, as_string=False, template_name="manage/manufacturers/products_inline.html"): """Displays the products-tab of a manufacturer. This is called at start from the manage_products view to assemble the whole manage manufacturer view and is subsequently called via ajax requests to update this part independent of others. """ req = request.POST if request.method == 'POST' else request.GET manufacturer = Manufacturer.objects.get(pk=manufacturer_id) if req.get("keep-session"): page = req.get("manufacturer_page", request.session.get("manufacturer_page", 1)) filter_ = req.get("manufacturer_filter", request.session.get("manufacturer_filter", "")) category_filter = req.get( "manufacturer_category_filter", request.session.get("manufacturer_category_filter", "")) else: page = 1 filter_ = "" category_filter = "" s = request.session s["manufacturer_page"] = page s["manufacturer_filter"] = filter_ s["manufacturer_category_filter"] = category_filter try: s["manufacturer-products-amount"] = int( req.get("manufacturer-products-amount", s.get("manufacturer-products-amount"))) except TypeError: s["manufacturer-products-amount"] = 25 filters = Q() if filter_: filters &= (Q(name__icontains=filter_) | Q(sku__icontains=filter_)) if category_filter: if category_filter == "None": filters &= Q(categories=None) elif category_filter == "All": pass else: category_temp = lfs_get_object_or_404(Category, pk=category_filter) categories_temp = [category_temp] categories_temp.extend(category_temp.get_all_children()) filters &= Q(categories__in=categories_temp) selectable_products = Product.objects.filter(filters).exclude( sub_type=VARIANT).exclude(manufacturer=manufacturer).distinct() paginator = Paginator(selectable_products, s["manufacturer-products-amount"]) try: page = paginator.page(page) except (EmptyPage, InvalidPage): page = paginator.page(1) result = render_to_string( template_name, RequestContext( request, { "manufacturer": manufacturer, "paginator": paginator, "page": page, "selected_products": selected_products(request, manufacturer_id, as_string=True), })) if as_string: return result else: return HttpResponse(json.dumps({ "html": [["#products-inline", result]], }), content_type='application/json')
def manage_featured_inline( request, as_string=False, template_name="manage/marketing/featured_inline.html"): """ """ featured = FeaturedProduct.objects.all() featured_ids = [f.product.id for f in featured] r = request.POST if request.method == 'POST' else request.GET s = request.session # If we get the parameter ``keep-filters`` or ``page`` we take the # filters out of the request resp. session. The request takes precedence. # The page parameter is given if the user clicks on the next/previous page # links. The ``keep-filters`` parameters is given is the users adds/removes # products. In this way we keeps the current filters when we needed to. If # the whole page is reloaded there is no ``keep-filters`` or ``page`` and # all filters are reset as they should. if r.get("keep-filters") or r.get("page"): page = r.get("page", s.get("featured_products_page", 1)) filter_ = r.get("filter", s.get("filter")) category_filter = r.get("featured_category_filter", s.get("featured_category_filter")) else: page = r.get("page", 1) filter_ = r.get("filter") category_filter = r.get("featured_category_filter") # The current filters are saved in any case for later use. s["featured_products_page"] = page s["filter"] = filter_ s["featured_category_filter"] = category_filter try: s["featured-amount"] = int( r.get("featured-amount", s.get("featured-amount"))) except TypeError: s["featured-amount"] = 25 filters = Q() if filter_: filters &= Q(name__icontains=filter_) filters |= Q(sku__icontains=filter_) filters |= (Q(sub_type=VARIANT) & Q(active_sku=False) & Q(parent__sku__icontains=filter_)) filters |= (Q(sub_type=VARIANT) & Q(active_name=False) & Q(parent__name__icontains=filter_)) if category_filter: if category_filter == "None": filters &= Q(categories=None) elif category_filter == "All": pass else: # First we collect all sub categories and using the `in` operator category = lfs_get_object_or_404(Category, pk=category_filter) categories = [category] categories.extend(category.get_all_children()) filters &= Q(categories__in=categories) products = Product.objects.filter(filters).exclude(pk__in=featured_ids) paginator = Paginator(products, s["featured-amount"]) total = products.count() try: page = paginator.page(page) except EmptyPage: page = 0 result = render_to_string(template_name, request=request, context={ "featured": featured, "total": total, "page": page, "paginator": paginator, "filter": filter_ }) if as_string: return result else: return HttpResponse(json.dumps({ "html": [["#featured-inline", result]], }), content_type='application/json')
def add_to_cart(request, product_id=None): """ Adds the passed product with passed product_id to the cart after some validations have been taken place. The amount is taken from the query string. """ if product_id is None: product_id = request.REQUEST.get("product_id") product = lfs_get_object_or_404(Product, pk=product_id) # Only active and deliverable products can be added to the cart. if not (product.is_active() and product.is_deliverable()): raise Http404() quantity = request.POST.get("quantity", "1.0") quantity = product.get_clean_quantity_value(quantity) # Validate properties (They are added below) properties_dict = {} if product.is_configurable_product(): for key, value in request.POST.items(): if key.startswith("property-"): try: property_group_id, property_id = key.split("-")[1:] except IndexError: continue try: prop = Property.objects.get(pk=property_id) except Property.DoesNotExist: continue property_group = None if property_group_id != '0': try: property_group = PropertyGroup.objects.get( pk=property_group_id) except PropertyGroup.DoesNotExist: continue if prop.is_number_field: try: value = lfs.core.utils.atof(value) except ValueError: value = 0.0 key = '{0}_{1}'.format(property_group_id, property_id) properties_dict[key] = { 'value': unicode(value), 'property_group_id': property_group_id, 'property_id': property_id } # validate property's value if prop.is_number_field: if (value < prop.unit_min) or (value > prop.unit_max): msg = _( u"%(name)s must be between %(min)s and %(max)s %(unit)s." ) % { "name": prop.title, "min": prop.unit_min, "max": prop.unit_max, "unit": prop.unit } return lfs.core.utils.set_message_cookie( product.get_absolute_url(), msg) # calculate valid steps steps = [] x = prop.unit_min while x < prop.unit_max: steps.append("%.2f" % x) x += prop.unit_step steps.append("%.2f" % prop.unit_max) value = "%.2f" % value if value not in steps: msg = _( u"Your entered value for %(name)s (%(value)s) is not in valid step width, which is %(step)s." ) % { "name": prop.title, "value": value, "step": prop.unit_step } return lfs.core.utils.set_message_cookie( product.get_absolute_url(), msg) if product.get_active_packing_unit(): quantity = product.get_amount_by_packages(quantity) cart = cart_utils.get_or_create_cart(request) cart_item = cart.add(product, properties_dict, quantity) cart_items = [cart_item] # Check stock amount message = "" if product.manage_stock_amount and cart_item.amount > product.stock_amount and not product.order_time: if product.stock_amount == 0: message = _( u"Sorry, but '%(product)s' is not available anymore.") % { "product": product.name } elif product.stock_amount == 1: message = _( u"Sorry, but '%(product)s' is only one time available.") % { "product": product.name } else: message = _( u"Sorry, but '%(product)s' is only %(amount)s times available." ) % { "product": product.name, "amount": product.stock_amount } cart_item.amount = product.stock_amount cart_item.save() # Add selected accessories to cart for key, value in request.POST.items(): if key.startswith("accessory"): accessory_id = key.split("-")[1] try: accessory = Product.objects.get(pk=accessory_id) except ObjectDoesNotExist: continue # for product with variants add default variant if accessory.is_product_with_variants(): accessory_variant = accessory.get_default_variant() if accessory_variant: accessory = accessory_variant else: continue # Get quantity quantity = request.POST.get("quantity-%s" % accessory_id, 0) quantity = accessory.get_clean_quantity_value(quantity) cart_item = cart.add(product=accessory, amount=quantity) cart_items.append(cart_item) # Store cart items for retrieval within added_to_cart. request.session["cart_items"] = cart_items cart_changed.send(cart, request=request) # Update the customer's shipping method (if appropriate) customer = customer_utils.get_or_create_customer(request) shipping_utils.update_to_valid_shipping_method(request, customer, save=True) # Update the customer's payment method (if appropriate) payment_utils.update_to_valid_payment_method(request, customer, save=True) # Save the cart to update modification date cart.save() try: url_name = settings.LFS_AFTER_ADD_TO_CART except AttributeError: url_name = "lfs_added_to_cart" if message: return lfs.core.utils.set_message_cookie(reverse(url_name), message) else: return HttpResponseRedirect(reverse(url_name))
def category_products( request, slug, start=1, template_name="lfs/catalog/categories/product/default.html"): """Displays the products of the category with passed slug. This view is called if the user chooses a template that is situated in settings.PRODUCT_PATH ". """ # Resets the product filters if the user navigates to another category. # TODO: Is this what a customer would expect? last_category = request.session.get("last_category") if (last_category is None) or (last_category.slug != slug): if "product-filter" in request.session: del request.session["product-filter"] if "price-filter" in request.session: del request.session["price-filter"] if "manufacturer-filter" in request.session: del request.session["manufacturer-filter"] try: default_sorting = settings.LFS_PRODUCTS_SORTING except AttributeError: default_sorting = "effective_price" sorting = request.session.get("sorting", default_sorting) product_filter = request.session.get("product-filter", {}) cache_key = "%s-category-products-2-%s" % ( settings.CACHE_MIDDLEWARE_KEY_PREFIX, slug) sub_cache_key = "%s-2-start-%s-sorting-%s" % ( settings.CACHE_MIDDLEWARE_KEY_PREFIX, start, sorting) filter_key = ["%s-%s" % (i[0], i[1]) for i in product_filter.items()] if filter_key: sub_cache_key += "-%s" % "-".join(filter_key) price_filter = request.session.get("price-filter") if price_filter: sub_cache_key += "-%s-%s" % (price_filter["min"], price_filter["max"]) manufacturer_filter = request.session.get("manufacturer-filter") if manufacturer_filter: sub_cache_key += "-%s" % ','.join(map(str, manufacturer_filter)) temp = cache.get(cache_key) if temp is not None: try: return temp[sub_cache_key] except KeyError: pass else: temp = dict() category = lfs_get_object_or_404(Category, slug=slug) # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 format_info = category.get_format_info() amount_of_rows = format_info["product_rows"] amount_of_cols = format_info["product_cols"] amount = amount_of_rows * amount_of_cols all_products = lfs.catalog.utils.get_filtered_products_for_category( category, product_filter, price_filter, sorting, manufacturer_filter) all_products = all_products.select_related('parent') # prepare paginator paginator = Paginator(all_products, amount) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) # Calculate products row = [] products = [] for i, product in enumerate(current_page.object_list): if product.is_product_with_variants(): default_variant = product.get_variant_for_category(request) if default_variant: product = default_variant image = None product_image = product.get_image() if product_image: image = product_image.image row.append({ "obj": product, "slug": product.slug, "name": product.get_name(), "image": image, "price_unit": product.get_price_unit(), "price_includes_tax": product.price_includes_tax(request), }) if (i + 1) % amount_of_cols == 0: products.append(row) row = [] if len(row) > 0: products.append(row) amount_of_products = all_products.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=category.get_absolute_url()) pagination_data['total_text'] = ungettext( '%(count)d product', '%(count)d products', amount_of_products) % { 'count': amount_of_products } render_template = category.get_template_name() if render_template is not None: template_name = render_template template_data = { "category": category, "products": products, "amount_of_products": amount_of_products, "pagination": pagination_data } result_html = render_to_string(template_name, RequestContext(request, template_data)) result = {'pagination_data': pagination_data, 'html': result_html} temp[sub_cache_key] = result cache.set(cache_key, temp) return result
def get_default_shop(): """Returns the default shop. At the moment this the shop with id == 1. """ return lfs_get_object_or_404(Shop, pk=1)
def get_image(self): """Returns the image for the page. """ shop = lfs_get_object_or_404(Shop, pk=1) return shop.image
def update_variants(request, product_id): """Updates/Deletes variants with passed ids (via request body) dependent on given action (also via request body). """ product = lfs_get_object_or_404(Product, pk=product_id) action = request.POST.get("action") if action == "delete": message = _(u"Variants have been deleted.") for key in request.POST.keys(): if key.startswith("delete-"): try: id = key.split("-")[1] variant = Product.objects.get(pk=id) except (IndexError, ObjectDoesNotExist): continue else: if product.default_variant == variant: product.default_variant = None product.save() variant.delete() elif action == "update": message = _(u"Variants have been saved.") for key, value in request.POST.items(): if key.startswith("variant-"): id = key.split("-")[1] try: variant = Product.objects.get(pk=id) except ObjectDoesNotExist: continue else: for name in ("slug", "sku", "price"): value = request.POST.get("%s-%s" % (name, id)) if value != "": setattr(variant, name, value) # name variant.name = request.POST.get("name-%s" % id) # active active = request.POST.get("active-%s" % id) if active: variant.active = True else: variant.active = False # active attributes for name in ("active_price", "active_sku", "active_name"): value = request.POST.get("%s-%s" % (name, id)) if value: setattr(variant, name, True) else: setattr(variant, name, False) # position position = request.POST.get("position-%s" % id) try: variant.variant_position = int(position) except ValueError: variant.variant_position = 10 # default variant try: product.default_variant_id = int( request.POST.get("default_variant")) except TypeError: pass else: product.save() variant.save() elif key.startswith("property"): # properties are marshalled as: property-variant_id|property_id temp = key.split("-")[1] variant_id, property_id = temp.split("|") variant = Product.objects.get(pk=variant_id) try: ppv = variant.property_values.get( property=property_id, type=PROPERTY_VALUE_TYPE_VARIANT) except ProductPropertyValue.DoesNotExist: # TODO: When creating new propertys (local or global), they are not copied onto existing variants. continue ppv.value = value ppv.save() # Refresh variant positions for i, variant in enumerate(product.variants.order_by("variant_position")): variant.variant_position = (i + 1) * 10 variant.save() # Send a signal to update cache product_changed.send(product) html = ( ("#variants", manage_variants(request, product_id, as_string=True)), ("#selectable-products-inline", _selectable_products_inline(request, product)), ) result = simplejson.dumps({ "html": html, "message": message, }, cls=LazyEncoder) return HttpResponse(result)
def products_inline( request, product_group_id, as_string=False, template_name="manage/property_groups/products_inline.html"): """Renders the products tab of the property groups management views. """ property_group = PropertyGroup.objects.get(pk=product_group_id) group_products = property_group.products.all().select_related('parent') r = request.REQUEST s = request.session # If we get the parameter ``keep-filters`` or ``page`` we take the # filters out of the request resp. session. The request takes precedence. # The page parameter is given if the user clicks on the next/previous page # links. The ``keep-filters`` parameters is given is the users adds/removes # products. In this way we keeps the current filters when we needed to. If # the whole page is reloaded there is no ``keep-filters`` or ``page`` and # all filters are reset as they should. if r.get("keep-filters") or r.get("page"): page = r.get("page", s.get("property_group_page", 1)) filter_ = r.get("filter", s.get("filter")) category_filter = r.get("products_category_filter", s.get("products_category_filter")) else: page = r.get("page", 1) filter_ = r.get("filter") category_filter = r.get("products_category_filter") # The current filters are saved in any case for later use. s["property_group_page"] = page s["filter"] = filter_ s["products_category_filter"] = category_filter filters = Q() if filter_: filters &= Q(name__icontains=filter_) if category_filter: if category_filter == "None": filters &= Q(categories=None) elif category_filter == "All": pass else: # First we collect all sub categories and using the `in` operator category = lfs_get_object_or_404(Category, pk=category_filter) categories = [category] categories.extend(category.get_all_children()) filters &= Q(categories__in=categories) products = Product.objects.select_related('parent').filter(filters) paginator = Paginator(products.exclude(pk__in=group_products), 25) try: page = paginator.page(page) except EmptyPage: page = 0 result = render_to_string( template_name, RequestContext( request, { "property_group": property_group, "group_products": group_products, "page": page, "paginator": paginator, "filter": filter_ })) if as_string: return result else: return HttpResponse(simplejson.dumps({ "html": [["#products-inline", result]], }), mimetype='application/json')