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, {})
