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')
