def manufacturers(request, template_name='lfs/manufacturers/manufacturers.html'): """ Display list of all manufacturers """ try: start = int((request.POST if request.method == 'POST' else request.GET).get("start", 1)) except (ValueError, TypeError): start = 1 manufacturers = Manufacturer.objects.all() # prepare paginator paginator = Paginator(manufacturers, 25) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) pagination_data = lfs_pagination(request, current_page, url=reverse('lfs_manufacturers')) count = manufacturers.count() pagination_data['total_text'] = ungettext('%(count)d manufacturer', '%(count)d manufacturers', count) % {'count': count} return render(request, template_name, { "pagination": pagination_data, "manufacturers": current_page.object_list, "all_manufacturers": manufacturers # pass it if someone doesn't want pagination })
def images(request, as_string=False, template_name="manage/images/images.html"): """ Display images management. """ req = request.POST if request.method == 'POST' else request.GET start = req.get('start') # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = req.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(content_id=None, title__istartswith=query) else: images_qs = Image.objects.filter(content_id=None) paginator = Paginator(images_qs, 50) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext( '%(count)d image', '%(count)d images', amount_of_images) % { 'count': amount_of_images } result = render_to_string(template_name, request=request, context={ "images": current_page.object_list, "pagination": pagination_data, "query": query }) if as_string: return result return HttpResponse(result)
def images(request, as_string=False, template_name="manage/images/images.html"): """ Display images management. """ req = request.POST if request.method == 'POST' else request.GET start = req.get('start') # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = req.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(content_id=None, title__istartswith=query) else: images_qs = Image.objects.filter(content_id=None) paginator = Paginator(images_qs, 50) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext('%(count)d image', '%(count)d images', amount_of_images) % {'count': amount_of_images} result = render_to_string(template_name, request=request, context={ "images": current_page.object_list, "pagination": pagination_data, "query": query }) if as_string: return result return HttpResponse(result)
def search(request, template_name="lfs/search/search_results.html"): """Returns the search result according to given query (via get request) ordered by the globally set sorting. """ q = request.GET.get("q", "") start = request.GET.get("start", 1) # Products query = Q(active=True) & (Q(name__icontains=q) | Q( manufacturer__name__icontains=q) | Q(sku_manufacturer__icontains=q)) products = Product.objects.filter(query) amount_of_products = products.count() # Sorting sorting = request.session.get("sorting") if sorting: products = products.order_by(sorting) # prepare paginator paginator = Paginator(products, 10) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) # Calculate urls pagination_data = lfs_pagination(request, current_page, url=reverse('lfs_search')) pagination_data['total_text'] = ungettext( '%(count)d product', '%(count)d products', amount_of_products) % { 'count': amount_of_products } return render( request, template_name, { "products": current_page, "pagination": pagination_data, "q": q, "total": products.count(), })
def images(request, template_name="manage/images/images.html"): """ Display images management. """ start = request.REQUEST.get('start') # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = request.REQUEST.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(title__istartswith=query) else: images_qs = Image.objects.all() paginator = Paginator(images_qs, 50) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext( '%(count)d image', '%(count)d images', amount_of_images) % { 'count': amount_of_images } return render( request, template_name, { "images": current_page.object_list, "pagination": pagination_data, "query": query })
def search(request, template_name="lfs/search/search_results.html"): """Returns the search result according to given query (via get request) ordered by the globally set sorting. """ q = request.GET.get("q", "") start = request.GET.get("start", 1) # Products query = Q(active=True) & ( Q(name__icontains=q) | Q(manufacturer__name__icontains=q) | Q(sku_manufacturer__icontains=q) ) products = Product.objects.filter(query) amount_of_products = products.count() # Sorting sorting = request.session.get("sorting") if sorting: products = products.order_by(sorting) # prepare paginator paginator = Paginator(products, 10) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) # Calculate urls pagination_data = lfs_pagination(request, current_page, url=reverse('lfs_search')) pagination_data['total_text'] = ungettext('%(count)d product', '%(count)d products', amount_of_products) % {'count': amount_of_products} return render(request, template_name, { "products": current_page, "pagination": pagination_data, "q": q, "total": products.count(), })
def manufacturers(request, template_name='lfs/manufacturers/manufacturers.html'): """ Display list of all manufacturers """ try: start = int( (request.POST if request.method == 'POST' else request.GET).get( "start", 1)) except (ValueError, TypeError): start = 1 manufacturers = Manufacturer.objects.all() # prepare paginator paginator = Paginator(manufacturers, 25) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) pagination_data = lfs_pagination(request, current_page, url=reverse('lfs_manufacturers')) count = manufacturers.count() pagination_data['total_text'] = ungettext( '%(count)d manufacturer', '%(count)d manufacturers', count) % { 'count': count } return render( request, template_name, { "pagination": pagination_data, "manufacturers": current_page.object_list, "all_manufacturers": manufacturers # pass it if someone doesn't want pagination })
def images(request, template_name="manage/images/images.html"): """ Display images management. """ start = request.REQUEST.get('start') # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = request.REQUEST.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(title__istartswith=query) else: images_qs = Image.objects.all() paginator = Paginator(images_qs, 50) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext('%(count)d image', '%(count)d images', amount_of_images) % {'count': amount_of_images} return render(request, template_name, { "images": current_page.object_list, "pagination": pagination_data, "query": query })
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", {}) product_filter = product_filter.items() 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] 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.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 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 manufacturer_products(request, slug, start=1, template_name="lfs/manufacturers/products.html"): """Displays the products of the manufacturer with passed slug. """ # Resets the product filters if the user navigates to another manufacturer. # TODO: Is this what a customer would expect? last_manufacturer = request.session.get("last_manufacturer") if (last_manufacturer is None) or (last_manufacturer.slug != slug): if "product-filter" in request.session: del request.session["product-filter"] if "price-filter" in request.session: del request.session["price-filter"] try: default_sorting = settings.LFS_PRODUCTS_SORTING except AttributeError: default_sorting = "price" sorting = request.session.get("sorting", default_sorting) product_filter = request.session.get("product-filter", {}) product_filter = product_filter.items() cache_key = "%s-manufacturer-products-%s" % ( settings.CACHE_MIDDLEWARE_KEY_PREFIX, slug) sub_cache_key = "%s-start-%s-sorting-%s" % ( settings.CACHE_MIDDLEWARE_KEY_PREFIX, start, sorting) filter_key = ["%s-%s" % (i[0], i[1]) for i in product_filter] 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"]) temp = cache.get(cache_key) if temp is not None: try: return temp[sub_cache_key] except KeyError: pass else: temp = dict() manufacturer = lfs_get_object_or_404(Manufacturer, slug=slug) # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 format_info = manufacturer.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 = manufacturer.get_filtered_products(product_filter, price_filter, sorting) # 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_default_variant() 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.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=manufacturer.get_absolute_url()) pagination_data['total_text'] = ungettext( '%(count)d product', '%(count)d products', amount_of_products) % { 'count': amount_of_products } result = render_to_string(template_name, request=request, context={ "manufacturer": manufacturer, "products": products, "amount_of_products": amount_of_products, "pagination": pagination_data, "all_products": all_products, }) temp[sub_cache_key] = result cache.set(cache_key, temp) return result
def manufacturer_products(request, slug, start=1, template_name="lfs/manufacturers/products.html"): """Displays the products of the manufacturer with passed slug. """ # Resets the product filters if the user navigates to another manufacturer. # TODO: Is this what a customer would expect? last_manufacturer = request.session.get("last_manufacturer") if (last_manufacturer is None) or (last_manufacturer.slug != slug): if "product-filter" in request.session: del request.session["product-filter"] if "price-filter" in request.session: del request.session["price-filter"] try: default_sorting = settings.LFS_PRODUCTS_SORTING except AttributeError: default_sorting = "price" sorting = request.session.get("sorting", default_sorting) product_filter = request.session.get("product-filter", {}) product_filter = product_filter.items() cache_key = "%s-manufacturer-products-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, slug) sub_cache_key = "%s-start-%s-sorting-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, start, sorting) filter_key = ["%s-%s" % (i[0], i[1]) for i in product_filter] 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"]) temp = cache.get(cache_key) if temp is not None: try: return temp[sub_cache_key] except KeyError: pass else: temp = dict() manufacturer = lfs_get_object_or_404(Manufacturer, slug=slug) # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 format_info = manufacturer.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 = manufacturer.get_filtered_products(product_filter, price_filter, sorting) # 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_default_variant() 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.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=manufacturer.get_absolute_url()) pagination_data['total_text'] = ungettext('%(count)d product', '%(count)d products', amount_of_products) % {'count': amount_of_products} result = render_to_string(template_name, request=request, context={ "manufacturer": manufacturer, "products": products, "amount_of_products": amount_of_products, "pagination": pagination_data, "all_products": all_products, }) temp[sub_cache_key] = result cache.set(cache_key, temp) return result
def imagebrowser(request, template_name="manage/images/filebrowser_images.html"): """ Displays a browser for images. """ selected_size = None selected_image = None selected_class = request.GET.get("class") url = request.GET.get("url") start = request.GET.get('start', 1) if url: parsed_url = urlparse.urlparse(url) try: temp_url = "/".join(parsed_url.path.split("/")[2:]) result = re.search("(.*)(\.)(\d+x\d+)(.*)", temp_url) if result: temp_url = result.groups()[0] + result.groups()[3] selected_image = Image.objects.get(image=temp_url) selected_size = result.groups()[2] else: value = None title = None selected_size = None except (IndexError, Image.DoesNotExist): pass sizes = [] for size in THUMBNAIL_SIZES: size = "%sx%s" % (size[0], size[1]) sizes.append({ "value": size, "title": size, "selected": size == selected_size, }) classes = [{"value": 'inline', "title": _(u'inline'), "selected": 'inline' == selected_class}, {"value": 'left', "title": _(u'left'), "selected": 'left' == selected_class}, {"value": 'right', "title": _(u'right'), "selected": 'right' == selected_class}] # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = request.REQUEST.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(title__istartswith=query) else: images_qs = Image.objects.all() paginator = Paginator(images_qs, 25) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext('%(count)d image', '%(count)d images', amount_of_images) % {'count': amount_of_images} images = [] for i, image in enumerate(current_page.object_list): images.append({ "id": image.id, "title": image.title, "checked": image == selected_image, "url": image.image.url_100x100, }) html = render_to_string(template_name, RequestContext(request, { "sizes": sizes, "classes": classes, "images": images, "query": query, "pagination": pagination_data })) result = simplejson.dumps({ "html": html, "message": "msg", }, cls=LazyEncoder) return HttpResponse(result, mimetype='application/json')
def shop_view(request,slug="", start=1, template_name="lfs/shop/shop.html"): """Displays the shop. """ shop = lfs_get_object_or_404(Shop, pk=1) #category = lfs_get_object_or_404(Category, slug='home-products') #all_products = category.get_all_products() #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"] try: default_sorting = settings.LFS_PRODUCTS_SORTING except AttributeError: default_sorting = "price" #sorting = request.session.get("sorting", default_sorting) sorting = default_sorting #product_filter = request.session.get("product-filter", {}) #product_filter = product_filter.items() product_filter = {} cache_key = "%s-category-products-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, slug) sub_cache_key = "%s-start-%s-sorting-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, start, sorting) filter_key = ["%s-%s" % (i[0], i[1]) for i in product_filter] 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"]) 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='home-products') # 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) # 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.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()) #render_template = category.get_template_name() #if render_template != None: # template_name = render_template return render_to_response(template_name, RequestContext(request, { "category": category, "products": products, "amount_of_products": amount_of_products, "pagination": pagination_data, "all_products": all_products, "shop":shop }))
def imagebrowser(request, template_name="manage/images/filebrowser_images.html"): """ Displays a browser for images. """ selected_size = None selected_image = None selected_class = request.GET.get("class") url = request.GET.get("url") start = request.GET.get('start', 1) if url: parsed_url = urlparse.urlparse(url) try: temp_url = "/".join(parsed_url.path.split("/")[2:]) result = re.search("(.*)(\.)(\d+x\d+)(.*)", temp_url) if result: temp_url = result.groups()[0] + result.groups()[3] selected_image = Image.objects.get(image=temp_url) selected_size = result.groups()[2] else: value = None title = None selected_size = None except (IndexError, Image.DoesNotExist): pass sizes = [] for size in THUMBNAIL_SIZES: size = "%sx%s" % (size[0], size[1]) sizes.append({ "value": size, "title": size, "selected": size == selected_size, }) classes = [{"value": 'inline', "title": _(u'inline'), "selected": 'inline' == selected_class}, {"value": 'left', "title": _(u'left'), "selected": 'left' == selected_class}, {"value": 'right', "title": _(u'right'), "selected": 'right' == selected_class}] # Calculates parameters for display. try: start = int(start) except (ValueError, TypeError): start = 1 # filter query = request.REQUEST.get('q', '') # prepare paginator if query: images_qs = Image.objects.filter(title__istartswith=query) else: images_qs = Image.objects.all() paginator = Paginator(images_qs, 25) try: current_page = paginator.page(start) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_images = images_qs.count() # Calculate urls pagination_data = lfs_pagination(request, current_page, url=request.path) pagination_data['total_text'] = ungettext('%(count)d image', '%(count)d images', amount_of_images) % {'count': amount_of_images} images = [] for i, image in enumerate(current_page.object_list): images.append({ "id": image.id, "title": image.title, "checked": image == selected_image, "url": image.image.url_100x100, }) html = render_to_string(template_name, RequestContext(request, { "sizes": sizes, "classes": classes, "images": images, "query": query, "pagination": pagination_data })) result = json.dumps({ "html": html, "message": "msg", }, cls=LazyEncoder) return HttpResponse(result, content_type='application/json')
def search(request, template_name="lfs/search/search_results.html"): """Provides form and result for search via Solr. """ # if not SOLR_ENABLED, urls.py does not call this view if request.GET.get("reset") or request.GET.get("livesearch"): try: del request.session["solr_filter"] except KeyError: pass rows = 10 q = request.GET.get("q") try: page = int(request.GET.get("start", 1)) except ValueError: page = 1 if q: params = { 'facet': 'on', 'facet.field': ['categories', 'manufacturer'], 'facet.mincount': 1, 'rows': rows, "start": (page - 1) * rows, "q": q, "wt": "json", } # Sorting sorting = '' sorting_value = request.session.get("sorting") if sorting_value: # check validity of sort param. # Since SOLR uses different sorting keys, we must find # correct sorting key # Example: session contains -price, we need to sort by 'price desc' for item in SORTING_MAP: if item['default'] == sorting_value: sorting = item.get('ftx') # returns correct sort key break if sorting: params["sort"] = sorting else: del request.session['sorting'] if "solr_filter" in request.session.keys(): params["fq"] = [] for field, value in request.session["solr_filter"].items(): params["fq"].append("%s:%s" % (field.encode("utf-8"), value.encode("utf-8"))) result = requests.get( SOLR_ADDRESS + "/select", headers={"content-type": "application/json"}, auth=HTTPBasicAuth(SOLR_USER, SOLR_PASSWORD), params=params, ) content = json.loads(result.content) docs = content["response"]["docs"] # Products products = [] for doc in docs: try: product = Product.objects.get(pk=doc["id"]) except Product.DoesNotExist: pass else: products.append(product) fake_results = SolrResults(products, content["response"]["numFound"], rows) # Facets categories = [] temp = content["facet_counts"]["facet_fields"]["categories"] for i in range(1, len(temp), 2): name = temp[i - 1] if name.find(" "): url = '"%s"' % name else: url = name categories.append({ "url": url, "name": name, "amount": temp[i], }) manufacturers = [] temp = content["facet_counts"]["facet_fields"]["manufacturer"] for i in range(1, len(temp), 2): name = temp[i - 1] if name: if name.find(" "): url = '"%s"' % name else: url = name manufacturers.append({ "url": url, "name": name, "amount": temp[i], }) paginator = Paginator(fake_results, rows) try: current_page = paginator.page(page) except (EmptyPage, InvalidPage): current_page = paginator.page(paginator.num_pages) amount_of_products = content["response"]["numFound"] # alculate urls pagination_data = lfs_pagination(request, current_page, url=reverse('lfs_search')) pagination_data['total_text'] = ungettext('%(count)d product', '%(count)d products', amount_of_products) % {'count': amount_of_products} return render(request, template_name, { "products": products, "results": content, "categories": categories, "manufacturers": manufacturers, "categories_reset": "categories" in request.session.get("solr_filter", []), "manufacturer_reset": "manufacturer" in request.session.get("solr_filter", []), "total": content["response"]["numFound"], "q": q, "sorting": sorting_value, 'pagination': pagination_data, }) else: return render(request, template_name, {})