def main():
breeds_list, links = parser_breeds()
breeds_list = breeds_list[61:160]
links = links[61:160]
description = breeds_links_read(links)
for i, breed in enumerate(breeds_list):
print('Start downloading images for ' + breed)
links = request_to_google_cse(API_KEY, breed, CUSTOM_SEARCH_ENGINE_ID,
NUMBER_IMG_REQUIR)
folder_single_breed_img = os.path.join(MEDIA_ROOT, 'uploads/product',
breed)
# create folder for each breed if it isn't exist
if not os.path.exists(folder_single_breed_img):
os.makedirs(folder_single_breed_img)
new_dog_product = Product(available=True,
title=breed,
content=description[i])
new_dog_product.save()
variation = ProductVariation(product=new_dog_product,
default=True,
unit_price=choice(PRICE_CHOICES),
sale_from=timezone.now())
variation.save()
for link in links['items']:
try:
img_resized = download_images_by_link(
breed, link['link'], IMG_WIDTH_REQUIR, IMG_HEIGHT_REQUIR,
os.path.join(MEDIA_ROOT, WATERMARK), WATERMARK_OPACITY,
MEDIA_ROOT)
# create a new instance of ProductImage class and link it with Product class
image = ProductImage(product=new_dog_product)
# assign path to image to ProductImage instance
image.file = img_resized
image.save()
print(img_resized + ' was downloaded')
except HTTPError:
print('HTTP Error 403: Forbidden. Link is not valid')
except OSError:
print('OSError.')
# Set the first instance of ProductImage as default image for default variation
new_dog_product.variations.set_default_images([])
# Copy duplicate fields (``Priced`` fields) from the default variation to the product.
new_dog_product.copy_default_variation()
def handle_wishlist(request, slug, form_class=AddProductForm):
if request.method == 'POST' and request.is_ajax():
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
initial_data = {}
variations = product.variations.all()
fields = [f.name for f in ProductVariation.option_fields()]
if variations:
initial_data = dict([(f, getattr(variations[0], f))
for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=False)
if add_product_form.is_valid():
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
messages.info(request, _("Item added to wishlist"))
response = render(request, 'messages.html')
set_cookie(response, "wishlist", ",".join(skus))
return response
return HttpResponse(json.dumps(add_product_form.errors),
content_type="application/json")
return HttpResponse('not post')
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
AddProductForm = get_add_product_form(product)
add_product_form = AddProductForm(initial={"quantity": 1})
if request.method == "POST":
to_cart = request.POST.get("add_wishlist") is None
add_product_form = AddProductForm(request.POST, to_cart=to_cart)
if add_product_form.is_valid():
if to_cart:
Cart.objects.from_request(request).add_item(
add_product_form.variation,
add_product_form.cleaned_data["quantity"])
info(request, _("Item added to cart"), fail_silently=True)
return HttpResponseRedirect(reverse("shop_cart"))
else:
skus = request.COOKIES.get("wishlist", "").split(",")
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"), fail_silently=True)
response = HttpResponseRedirect(reverse("shop_wishlist"))
set_cookie(response, "wishlist", ",".join(skus))
return response
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in
["sku", "image_id"] + [f.name for f in ProductVariation.option_fields()]])
for v in variations])
return render_to_response(template, {"product": product, "variations_json":
variations_json, "variations": variations, "images": product.images.all(),
"add_product_form": add_product_form}, RequestContext(request))
def cart_item_view(request, template="shop/product.html", form_class=AddProductForm, extra_content=None, cart_id="", item_id=""):
cart = Cart.objects.filter(id=cart_id).first()
item = next(item for item in cart.items.iterator() if item.id == int(item_id))
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=item.url.split('/')[-1])
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
variation = ProductVariation.objects.filter(sku=item.sku).first()
v_json = dict([(f, getattr(variation, f))
for f in fields + ["sku", "image_id"] if getattr(variation, f) is not None])
initial_data = dict(quantity=item.quantity, **v_json)
initial_data['embroidery_type'] = item.personalization.embroidery_type
initial_data['value'] = item.personalization.value
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=False)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"add_product_form": add_product_form,
"item": item
}
return render(request, template, context)
def product_api(request, slug):
data, body, header = {}, {}, {}
try:
product = Product.objects.get(slug=slug)
except Exception as e:
raise e
fields = [f.name for f in ProductVariation.option_fields()]
body['variations'] = [p.options()[0] for p in product.variations.all()]
body['variations_name'] = SHOP_OPTION_TYPE_CHOICES[0][1]
print(SHOP_OPTION_TYPE_CHOICES)
# body['variations'] = json.dumps([dict([(f, getattr(v, f))
# for f in fields + ["sku", "image_id"]]) for v in product.variations.all()])
body['context'] = serializers.serialize('json', [product])
body['images'] = serializers.serialize('json', product.images.all())
#body['context'] = filterData(product)
header['code'] = 200
header['message'] = 'success'
data['header'] = header
data['body'] = body
# for p in ProductOption.objects.all():
# print(p.name, SHOP_OPTION_TYPE_CHOICES[p.type-1][1])
print(body['variations'])
return HttpResponse(json.dumps(data), content_type="application/json")
def test_product_image_deletion_does_not_delete_referenced_variation(self):
try:
from io import BytesIO
except ImportError:
from cStringIO import StringIO as BytesIO
stream = BytesIO()
from PIL import Image
im = Image.new("RGB", (50, 50), "white")
im.save(stream, "png")
del im
stream.seek(0)
from django.core.files import File
product = Product(title="Doodah", unit_price="2.99")
product.save()
image = ProductImage(product_id=product.id, file=File(stream))
image.save()
ProductVariation(
unit_price="1.99", product_id=product.id, default=True, image=image
).save()
self.assertEqual(product.variations.count(), 1)
image.delete()
self.assertEqual(product.variations.count(), 1)
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = simplejson.dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = AddProductForm(request.POST or None,
product=product,
initial=initial_data,
to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_discount(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
context = {
"product":
product,
"editable_obj":
product,
"images":
product.images.all(),
"variations":
variations,
"variations_json":
variations_json,
"has_available_variations":
any([v.has_price() for v in variations]),
"related_products":
product.related_products.published(for_user=request.user),
"add_product_form":
add_product_form
}
templates = [u"shop/%s.html" % unicode(product.slug), template]
return render(request, templates, context)
def variations_json(variations):
"""
Gets variations including the num_in_stock attribute into json format.
"""
fields = [field.name for field in ProductVariation.option_fields()]
variations_json = dumps([dict([(field, str(getattr(variation, field))) if isinstance(getattr(variation, field), Decimal) else (field, getattr(variation, field))
for field in fields + ["sku", "image_id", "num_in_stock"]]) for variation in variations])
return variations_json
def product(request, slug, template="shop/product.html",
form_class=AddProductForm, extra_context=None):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect("shop:shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop:shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form
}
context.update(extra_context or {})
templates = [u"shop/%s.html" % str(product.slug), template]
# Check for a template matching the page's content model.
if getattr(product, 'content_model', None) is not None:
templates.insert(0, u"shop/products/%s.html" % product.content_model)
return TemplateResponse(request, templates, context)
def product(request, slug, template="shop/product.html",
form_class=AddProductForm, extra_context=None):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form
}
context.update(extra_context or {})
templates = [u"shop/%s.html" % str(product.slug), template]
# Check for a template matching the page's content model.
if getattr(product, 'content_model', None) is not None:
templates.insert(0, u"shop/products/%s.html" % product.content_model)
return TemplateResponse(request, templates, context)
def _add_to_cart(self, variation, quantity):
"""
Given a variation, creates the dict for posting to the cart
form to add the variation, and posts it.
"""
field_names = [f.name for f in ProductVariation.option_fields()]
data = dict(list(zip(field_names, variation.options())))
data["quantity"] = quantity
self.client.post(variation.product.get_absolute_url(), data)
def _add_to_cart(self, variation, quantity):
"""
Given a variation, creates the dict for posting to the cart
form to add the variation, and posts it.
"""
field_names = [f.name for f in ProductVariation.option_fields()]
data = dict(list(zip(field_names, variation.options())))
data["quantity"] = quantity
self.client.post(variation.product.get_absolute_url(), data)
def setUp(self):
product1 = Product(unit_price="1.27")
product1.save()
ProductVariation(unit_price="1.27", product_id=product1.id).save()
ProductVariation(unit_price="1.27", product_id=product1.id).save()
product2 = Product(unit_price="1.27")
product2.save()
ProductVariation(unit_price="1.27", product_id=product2.id).save()
ProductVariation(unit_price="1.27", product_id=product2.id).save()
sale = Sale(title="30% OFF - Ken Bruce has gone mad!", discount_percent="30")
sale.save()
sale.products.add(product1)
sale.products.add(product2)
sale.save()
def test_cart(self):
"""
Test the cart object and cart add/remove forms.
"""
self._product.variations.all().delete()
self._product.variations.create_from_options(self._options)
variation = self._product.variations.all()[0]
variation.unit_price = TEST_PRICE
variation.num_in_stock = TEST_STOCK * 2
variation.save()
# Test initial cart.
cart = Cart.objects.from_request(self.client)
self.assertFalse(cart.has_items())
self.assertEqual(cart.total_quantity(), 0)
self.assertEqual(cart.total_price(), Decimal("0"))
# Add quantity and check stock levels / cart totals.
field_names = [f.name for f in ProductVariation.option_fields()]
data = dict(zip(field_names, variation.options()))
data["quantity"] = TEST_STOCK
self.client.post(self._product.get_absolute_url(), data)
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertTrue(variation.has_stock(TEST_STOCK))
self.assertFalse(variation.has_stock(TEST_STOCK * 2))
self.assertTrue(cart.has_items())
self.assertEqual(cart.total_quantity(), TEST_STOCK)
self.assertEqual(cart.total_price(), TEST_PRICE * TEST_STOCK)
# Add remaining quantity and check again.
self.client.post(self._product.get_absolute_url(), data)
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertFalse(variation.has_stock())
self.assertTrue(cart.has_items())
self.assertEqual(cart.total_quantity(), TEST_STOCK * 2)
self.assertEqual(cart.total_price(), TEST_PRICE * TEST_STOCK * 2)
# Remove from cart.
data = {"items-INITIAL_FORMS": 0, "items-TOTAL_FORMS": 0,
"update_cart": 1}
for i, item in enumerate(cart):
data["items-INITIAL_FORMS"] += 1
data["items-TOTAL_FORMS"] += 1
data["items-%s-id" % i] = item.id
data["items-%s-DELETE" % i] = "on"
self.client.post(reverse("shop_cart"), data)
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertTrue(variation.has_stock(TEST_STOCK * 2))
self.assertFalse(cart.has_items())
self.assertEqual(cart.total_quantity(), 0)
self.assertEqual(cart.total_price(), Decimal("0"))
def add_to_cart(request):
if not request.method == 'POST':
print('AAAA')
return HttpResponse({}, status=400)
print(request.POST)
slug = request.POST.get('product-slug')
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = json.dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = AddProductForm(request.POST or None,
product=product,
initial=initial_data,
to_cart=to_cart)
if request.method == "POST":
print(add_product_form)
if add_product_form.is_valid():
if to_cart:
print('PRODUCT_FORM', add_product_form)
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
#info(request, _("Item added to cart"))
#return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
#info(requesadd_to_cartt, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
#return response
data = {
'total_price': format(request.cart.total_price(), '.2f'),
'total_quantity': request.cart.total_quantity(),
'wishlist': len(request.wishlist)
}
print(data)
return HttpResponse(json.dumps(data), content_type="application/json")
def __init__(self, *args, **kwargs):
"""
Handles adding a variation to the cart or wishlist.
When adding from the product page, the product is provided
from the view and a set of choice fields for all the
product options for this product's variations are added to
the form. When the form is validated, the selected options
are used to determine the chosen variation.
A ``to_cart`` boolean keyword arg is also given specifying
whether the product is being added to a cart or wishlist.
If a product is being added to the cart, then its stock
level is also validated.
When adding to the cart from the wishlist page, a sku is
given for the variation, so the creation of choice fields
is skipped.
"""
self._product = kwargs.pop("product", None)
self._to_cart = kwargs.pop("to_cart")
super(AddProductForm, self).__init__(*args, **kwargs)
# Adding from the wishlist with a sku, bail out.
if args[0] is not None and args[0].get("sku", None):
return
# Adding from the product page, remove the sku field
# and build the choice fields for the variations.
del self.fields["sku"]
option_fields = ProductVariation.option_fields()
if not option_fields:
return
option_names, option_labels = list(
zip(*[(f.name, f.verbose_name) for f in option_fields]))
option_values = list(
zip(*self._product.variations.filter(
unit_price__isnull=False).values_list(*option_names)))
if option_values:
for i, name in enumerate(option_names):
values = [_f for _f in set(option_values[i]) if _f]
if values:
field = forms.ChoiceField(label=option_labels[i],
choices=make_choices(values))
self.fields[name] = field
if self._product.content_model == 'reservableproduct':
# ReservableProduct needs from/to dates and does not need quantity
self.fields["from_date"] = forms.DateField(
input_formats=["%d.%m.%Y"], widget=forms.HiddenInput())
self.fields["to_date"] = forms.DateField(
input_formats=["%d.%m.%Y"], widget=forms.HiddenInput())
self.fields["quantity"] = forms.IntegerField(
min_value=1, initial=1, widget=forms.HiddenInput())
def test_cart(self):
"""
Test the cart object and cart add/remove forms.
"""
product_options = ProductOption.objects.as_fields()
self._product.variations.all().delete()
self._product.variations.create_from_options(product_options)
price = Decimal("20")
num_in_stock = 5
variation = self._product.variations.all()[0]
variation.unit_price = price
variation.num_in_stock = num_in_stock * 2
variation.save()
# Test initial cart.
cart = Cart.objects.from_request(self.client)
self.assertFalse(cart.has_items())
self.assertEqual(cart.total_quantity(), 0)
self.assertEqual(cart.total_price(), Decimal("0"))
# Add quantity and check stock levels / cart totals.
data = dict(zip([field.name for field in
ProductVariation.option_fields()], variation.options()))
data["quantity"] = num_in_stock
self.client.post(self._product.get_absolute_url(), data)
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertTrue(variation.has_stock(num_in_stock))
self.assertFalse(variation.has_stock(num_in_stock * 2))
self.assertTrue(cart.has_items())
self.assertEqual(cart.total_quantity(), num_in_stock)
self.assertEqual(cart.total_price(), price * num_in_stock)
# Add remaining quantity and check again.
self.client.post(self._product.get_absolute_url(), data)
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertFalse(variation.has_stock())
self.assertTrue(cart.has_items())
self.assertEqual(cart.total_quantity(), num_in_stock * 2)
self.assertEqual(cart.total_price(), price * num_in_stock * 2)
# Remove from cart.
for item in cart:
self.client.post(reverse("shop_cart"), {"item_id": item.id})
cart = Cart.objects.from_request(self.client)
variation = self._product.variations.all()[0]
self.assertTrue(variation.has_stock(num_in_stock * 2))
self.assertFalse(cart.has_items())
self.assertEqual(cart.total_quantity(), 0)
self.assertEqual(cart.total_price(), Decimal("0"))
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]])
for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = AddProductForm(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_discount(request)
recalculate_billship_tax(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": product.related_products.published(
for_user=request.user),
"add_product_form": add_product_form
}
templates = [u"shop/%s.html" % unicode(product.slug), template]
return render(request, templates, context)
def __init__(self, *args, **kwargs):
"""
Handles adding a variation to the cart or wishlist.
When adding from the product page, the product is provided
from the view and a set of choice fields for all the
product options for this product's variations are added to
the form. When the form is validated, the selected options
are used to determine the chosen variation.
A ``to_cart`` boolean keyword arg is also given specifying
whether the product is being added to a cart or wishlist.
If a product is being added to the cart, then its stock
level is also validated.
When adding to the cart from the wishlist page, a sku is
given for the variation, so the creation of choice fields
is skipped.
"""
self._product = kwargs.pop("product", None)
self._to_cart = kwargs.pop("to_cart")
super(AddProductForm, self).__init__(*args, **kwargs)
# Adding from the wishlist with a sku, bail out.
if args[0] is not None and args[0].get("sku", None):
return
# Adding from the product page, remove the sku field
# and build the choice fields for the variations.
del self.fields["sku"]
option_fields = ProductVariation.option_fields()
if not option_fields:
return
option_names, option_labels = list(zip(*[(f.name, f.verbose_name)
for f in option_fields]))
option_values = list(zip(*self._product.variations.filter(
unit_price__isnull=False).values_list(*option_names)))
if option_values:
for i, name in enumerate(option_names):
values = [_f for _f in set(option_values[i]) if _f]
if values:
field = forms.ChoiceField(label=option_labels[i],
choices=make_choices(values))
self.fields[name] = field
if self._product.content_model == 'reservableproduct':
# ReservableProduct needs from/to dates and does not need quantity
self.fields["from_date"] = forms.DateField(input_formats=["%d.%m.%Y"], widget=forms.HiddenInput())
self.fields["to_date"] = forms.DateField(input_formats=["%d.%m.%Y"], widget=forms.HiddenInput())
self.fields["quantity"] = forms.IntegerField(min_value=1, initial=1, widget=forms.HiddenInput())
def __init__(self, *args, **kwargs):
"""
Handles adding a variation to the cart or wishlist.
When adding from the product page, the product is provided
from the view and a set of choice fields for all the
product options for this product's variations are added to
the form. When the form is validated, the selected options
are used to determine the chosen variation.
A ``to_cart`` boolean keyword arg is also given specifying
whether the product is being added to a cart or wishlist.
If a product is being added to the cart, then its stock
level is also validated.
When adding to the cart from the wishlist page, a sku is
given for the variation, so the creation of choice fields
is skipped.
"""
self._product = kwargs.pop("product", None)
self._to_cart = kwargs.pop("to_cart")
super(AddProductForm, self).__init__(*args, **kwargs)
# Adding from the wishlist with a sku, bail out.
if args[0] is not None and args[0].get("sku", None):
return
# Adding from the product page, remove the sku field
# and build the choice fields for the variations.
del self.fields["sku"]
option_fields = ProductVariation.option_fields()
if not option_fields:
return
option_names, option_labels = zip(*[(f.name, f.verbose_name)
for f in option_fields])
option_values = zip(*self._product.variations.filter(
unit_price__isnull=False).values_list(*option_names))
if option_values:
for i, name in enumerate(option_names):
values = list(option_values[i])
try:
values.remove(None)
except ValueError:
pass
if values:
field = forms.ChoiceField(label=option_labels[i],
choices=make_choices(values))
self.fields[name] = field
def __init__(self, *args, **kwargs):
"""
Handles adding a variation to the cart or wishlist.
When adding from the product page, the product is provided
from the view and a set of choice fields for all the
product options for this product's variations are added to
the form. When the form is validated, the selected options
are used to determine the chosen variation.
A ``to_cart`` boolean keyword arg is also given specifying
whether the product is being added to a cart or wishlist.
If a product is being added to the cart, then its stock
level is also validated.
When adding to the cart from the wishlist page, a sku is
given for the variation, so the creation of choice fields
is skipped.
"""
self._product = kwargs.pop("product", None)
self._to_cart = kwargs.pop("to_cart")
super(AddProductForm, self).__init__(*args, **kwargs)
# Adding from the wishlist with a sku, bail out.
if args[0] is not None and args[0].get("sku", None):
return
# Adding from the product page, remove the sku field
# and build the choice fields for the variations.
del self.fields["sku"]
option_fields = ProductVariation.option_fields()
if not option_fields:
return
option_names, option_labels = zip(*[(f.name, f.verbose_name)
for f in option_fields])
option_values = zip(*self._product.variations.filter(
unit_price__isnull=False).values_list(*option_names))
if option_values:
for i, name in enumerate(option_names):
values = list(option_values[i])
try:
values.remove(None)
except ValueError:
pass
if values:
field = forms.ChoiceField(label=option_labels[i],
choices=make_choices(values))
self.fields[name] = field
def __init__(self, *args, **kwargs):
"""
Create each ChoiceField for selecting from the product's variations.
"""
self._to_cart = kwargs.pop("to_cart", True)
super(AddProductForm, self).__init__(*args, **kwargs)
option_names, option_labels = zip(*[(f.name, f.verbose_name)
for f in ProductVariation.option_fields()])
option_values = zip(*product.variations.filter(
unit_price__isnull=False).values_list(*option_names))
if option_values:
for i, name in enumerate(option_names):
values = filter(None, set(option_values[i]))
if values:
field = forms.ChoiceField(label=option_labels[i],
choices=make_choices(values))
self.fields[name] = field
def product(request, prod, template="shop/product.html",
form_class=AddProductForm):
#pdb.set_trace()
fields = [f.name for f in ProductVariation.option_fields()]
variations = prod.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=prod,
initial=initial_data, to_cart=to_cart)
context = {
"variations": variations,
"add_product_form": add_product_form
}
return context
def cart_item_view(request,
template="shop/product.html",
form_class=AddProductForm,
extra_content=None,
cart_id="",
item_id=""):
cart = Cart.objects.filter(id=cart_id).first()
item = next(item for item in cart.items.iterator()
if item.id == int(item_id))
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products,
slug=item.url.split('/')[-1])
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
variation = ProductVariation.objects.filter(sku=item.sku).first()
v_json = dict([(f, getattr(variation, f))
for f in fields + ["sku", "image_id"]
if getattr(variation, f) is not None])
initial_data = dict(quantity=item.quantity, **v_json)
initial_data['embroidery_type'] = item.personalization.embroidery_type
initial_data['value'] = item.personalization.value
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=False)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"add_product_form": add_product_form,
"item": item
}
return render(request, template, context)
def parse_description(value, autoescape=True):
"""
Split product description to title and options to allow different styling.
Returns html with title and options in two lines with different classes:
'title' and 'options'.
"""
option_fields = ProductVariation.option_fields()
if option_fields:
first_option_label = option_fields[0].verbose_name
m = re.match(ur"(.*\w*)\s(%s.*)$" % first_option_label, value, re.I | re.U)
if m:
title = m.group(1)
options = m.group(2)
if autoescape:
esc = conditional_escape
else:
esc = lambda x: x
return mark_safe(
"<span class='title'>%s</span><br><span class='options'>%s</span>" % (esc(title), esc(options)))
else:
return value
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
to_cart = request.method == "POST" and request.POST.get("add_wishlist") is None
add_product_form = AddProductForm(request.POST or None, product=product, initial={"quantity": 1}, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_discount(request)
info(request, _("Item added to cart"))
return HttpResponseRedirect(reverse("shop_cart"))
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = HttpResponseRedirect(reverse("shop_wishlist"))
set_cookie(response, "wishlist", ",".join(skus))
return response
fields = [f.name for f in ProductVariation.option_fields()]
fields += ["sku", "image_id"]
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f)) for f in fields]) for v in variations])
context = {
"product": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related": product.related_products.published(for_user=request.user),
"add_product_form": add_product_form,
}
return render_to_response(template, context, RequestContext(request))
def product(request,
prod,
template="shop/product.html",
form_class=AddProductForm):
#pdb.set_trace()
fields = [f.name for f in ProductVariation.option_fields()]
variations = prod.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None,
product=prod,
initial=initial_data,
to_cart=to_cart)
context = {"variations": variations, "add_product_form": add_product_form}
return context
def test_order(self):
"""
Test that a completed order contains cart items and that
they're removed from stock.
"""
# Get a variation.
self._product.variations.all().delete()
self._product.variations.create_from_options(self._options)
variation = self._product.variations.all()[0]
variation.unit_price = TEST_PRICE
variation.num_in_stock = TEST_STOCK * 2
variation.save()
# Add to cart.
field_names = [f.name for f in ProductVariation.option_fields()]
data = dict(zip(field_names, variation.options()))
data["quantity"] = TEST_STOCK
self.client.post(self._product.get_absolute_url(), data)
cart = Cart.objects.from_request(self.client)
# Post order.
data = {"step": len(CHECKOUT_STEPS)}
self.client.post(reverse("shop_checkout"), data)
try:
order = Order.objects.from_request(self.client)
except Order.DoesNotExist:
self.fail("Couldn't create an order")
items = order.items.all()
variation = self._product.variations.all()[0]
self.assertEqual(cart.total_quantity(), 0)
self.assertEqual(len(items), 1)
self.assertEqual(items[0].sku, variation.sku)
self.assertEqual(items[0].quantity, TEST_STOCK)
self.assertEqual(variation.num_in_stock, TEST_STOCK)
self.assertEqual(order.item_total, TEST_PRICE * TEST_STOCK)
def handle_wishlist(request, slug, form_class=AddProductForm):
if request.method == 'POST' and request.is_ajax():
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
initial_data = {}
variations = product.variations.all()
fields = [f.name for f in ProductVariation.option_fields()]
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=product, initial=initial_data, to_cart=False)
if add_product_form.is_valid():
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
messages.info(request, _("Item added to wishlist"))
response = render(request,'messages.html')
set_cookie(response, "wishlist", ",".join(skus))
return response
return HttpResponse(json.dumps(add_product_form.errors), content_type="application/json")
return HttpResponse('not post')
TabularDynamicInlineAdmin,
BaseTranslationModelAdmin)
from mezzanine.pages.admin import PageAdmin
from cartridge.shop.fields import MoneyField
from cartridge.shop.forms import ProductAdminForm, ProductVariationAdminForm
from cartridge.shop.forms import ProductVariationAdminFormset
from cartridge.shop.forms import DiscountAdminForm, ImageWidget, MoneyWidget
from cartridge.shop.models import Category, Product, ProductImage
from cartridge.shop.models import ProductVariation, ProductOption, Order
from cartridge.shop.models import OrderItem, Sale, DiscountCode
from cartridge.shop.views import HAS_PDF
# Lists of field names.
option_fields = [f.name for f in ProductVariation.option_fields()]
_flds = lambda s: [f.name for f in Order._meta.fields if f.name.startswith(s)]
billing_fields = _flds("billing_detail")
shipping_fields = _flds("shipping_detail")
################
# CATEGORIES #
################
# Categories fieldsets are extended from Page fieldsets, since
# categories are a Mezzanine Page type.
category_fieldsets = deepcopy(PageAdmin.fieldsets)
category_fieldsets[0][1]["fields"][3:3] = ["content", "products"]
category_fieldsets += ((_("Product filters"), {
"fields": ("sale", ("price_min", "price_max"), "combined"),
def product(request,
slug,
template="shop/product.html",
form_class=AddProductForm):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect(request.path)
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
context = {
"product":
product,
"editable_obj":
product,
"images":
product.images.all(),
"variations":
variations,
"variations_json":
variations_json,
"has_available_variations":
any([v.has_price() for v in variations]),
"related_products":
related,
"add_product_form":
add_product_form,
"categories":
product.categories.all()[0].get_ascendants()[::-1] +
[product.categories.all()[0]]
}
# templates = [u"shop/%s.html" % str(product.slug), template]
templates = []
# Check for a template matching the page's content model.
if product.content_model is not None and product.content_model != 'product':
templates.append(u"shop/products/%s.html" % product.content_model)
context["characteristics"] = product.get_content_model(
).get_characteristics()
if product.content_model in ('productportal', 'productfacing'):
context["suitable_hearth"] = product.get_content_model(
).suitable_hearth.published(for_user=request.user)
context["suitable_topka"] = product.get_content_model(
).suitable_topka.published(for_user=request.user)
if product.content_model in ('producthearth', 'producttopka'):
context["suitable_faces"] = product.get_content_model(
).suitable_faces.published(for_user=request.user)
context["suitable_portals"] = product.get_content_model(
).suitable_portals.published(for_user=request.user)
templates.append(template)
return render(request, templates, context)
def product(request, slug, template="shop/product.html",
form_class=AddProductForm):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
if product.content_model == 'reservableproduct':
from_date = add_product_form.cleaned_data["from_date"]
to_date = add_product_form.cleaned_data["to_date"]
else:
from_date = None
to_date = None
request.cart.add_item(add_product_form.variation, quantity, from_date, to_date)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
if product.content_model == 'reservableproduct':
reservable = ReservableProduct.objects.get(id=product.id)
reservations = reservable.reservations.all()
else:
reservations = None
reservable = None
timespecials = product.specialprices.filter(special_type='PER', to_date__gte=date.today())
try:
weekendspecial = product.specialprices.get(special_type='WKD')
except SpecialPrice.DoesNotExist:
weekendspecial = False
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form,
"reservations": reservations,
"reservable": reservable,
"timespecials": timespecials,
"weekendspecial": weekendspecial,
}
templates = [u"shop/%s.html" % str(product.slug), template]
# Check for a template matching the page's content model.
if product.content_model is not None:
templates.insert(0, u"shop/products/%s.html" % product.content_model)
templates.append(template)
return render(request, templates, context)
def product(request,
slug,
template="shop/product.html",
form_class=AddProductForm,
extra_context=None):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
try:
# set title = membership level + product slug ("statue+gold")
# discount = DiscountCode.objects.filter(title="{}+{}".format(product.sku, request.user.membership.level))[0]
discount = get_or_update_discount(request, sku=product.sku)
# discount_percent = (100 - discount.discount_percent)/100
discount_deduction = discount.discount_deduct
except:
discount_deduction = 0
try:
c = CurrencyRates()
hkd_rate = c.get_rate('CNY', 'HKD')
except:
hkd_rate = 1.1584
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form,
"discount": discount_deduction,
"hkd_rate": hkd_rate
}
context.update(extra_context or {})
templates = [u"shop/%s.html" % str(product.slug), template]
return TemplateResponse(request, templates, context)
def buscarDominio(request):
resultado = ''
domain = ''
dominio = ''
extension = ''
precio = ''
duracion = 1
descripcion = ''
precio_total = ''
price_unit = ''
if request.method == 'POST' and 'buscar' in request.POST:
consulta = BuscarDominioForm(request.POST)
if consulta.is_valid():
dominio = consulta.cleaned_data['dominio']
extension = consulta.cleaned_data['extension']
duracion = consulta.cleaned_data['duracion']
duracion = int(duracion)
request.session['dur'] = duracion
dominio = str(dominio)
sufijo = str(extension)
domain = dominio + '.' + sufijo
request.session['dom'] = domain
result = api.domain.available(apikey, [domain])
while result[domain] == 'pending':
time.sleep(0.7)
result = api.domain.available(apikey, [domain])
if result[domain] == 'available':
resultado = domain + ' se encuentra disponible'
product_spec = {
'product': {
'description': domain,
'type': 'domain'
},
'action': {
'name': 'create',
'duration': duracion
}
}
result = api.catalog.list(apikey, product_spec)
result2 = result[0]
price = result2['unit_price']
price2 = price[0]
price_unit = price2['price']
precio = (price_unit + 4) * 4
request.session['pr_un'] = price_unit
request.session['pre'] = precio
precio_total = precio * duracion
break
elif result[domain] == 'unavailable':
resultado = domain + ' no se encuentra disponible'
break
request.session['res'] = resultado
elif request.method == 'POST' and 'registro' in request.POST:
producto = Product()
dominio = request.session.get('dom')
dominio = str(dominio)
unit_price = request.session.get('pr_un')
sale_price = request.session.get('pre')
producto.unit_price = unit_price
producto.sale_price = sale_price
producto.num_in_stock = 30
producto.sku = Product.objects.all().count() + 1
duracion = request.session.get('dur')
producto.available = True
producto.title = dominio
producto.save()
product = ProductVariation()
product.product = producto
product.unit_price = unit_price
product.sale_price = sale_price
product.num_in_stock = 30
product.sku = ProductVariation.objects.all().count() + 1
product.save()
request.cart.add_item(product, duracion)
recalculate_cart(request)
return HttpResponseRedirect('/shop/cart/')
else:
consulta = BuscarDominioForm()
return render_to_response('buscadominioform.html', {
'consulta': consulta,
'resultado': resultado,
'precio': precio_total
},
context_instance=RequestContext(request))
from mezzanine.conf import settings
from mezzanine.core.admin import (DisplayableAdmin, TabularDynamicInlineAdmin,
BaseTranslationModelAdmin)
from mezzanine.pages.admin import PageAdmin
from cartridge.shop.fields import MoneyField
from cartridge.shop.forms import ProductAdminForm, ProductVariationAdminForm
from cartridge.shop.forms import ProductVariationAdminFormset
from cartridge.shop.forms import DiscountAdminForm, ImageWidget, MoneyWidget
from cartridge.shop.models import Category, Product, ProductImage
from cartridge.shop.models import ProductVariation, ProductOption, Order
from cartridge.shop.models import OrderItem, Sale, DiscountCode
from cartridge.shop.views import HAS_PDF
# Lists of field names.
option_fields = [f.name for f in ProductVariation.option_fields()]
_flds = lambda s: [f.name for f in Order._meta.fields if f.name.startswith(s)]
billing_fields = _flds("billing_detail")
shipping_fields = _flds("shipping_detail")
################
# CATEGORIES #
################
# Categories fieldsets are extended from Page fieldsets, since
# categories are a Mezzanine Page type.
category_fieldsets = deepcopy(PageAdmin.fieldsets)
category_fieldsets[0][1]["fields"][3:3] = ["content", "products"]
category_fieldsets += ((
_("Product filters"),
{
def buscarDominio(request):
resultado = ''
domain = ''
dominio = ''
extension = ''
precio = ''
duracion = 1
descripcion = ''
precio_total = ''
price_unit = ''
if request.method=='POST' and 'buscar' in request.POST:
consulta = BuscarDominioForm(request.POST)
if consulta.is_valid():
dominio = consulta.cleaned_data['dominio']
extension = consulta.cleaned_data['extension']
duracion = consulta.cleaned_data['duracion']
duracion = int(duracion)
request.session['dur'] = duracion
dominio = str(dominio)
sufijo = str(extension)
domain = dominio + '.' + sufijo
request.session['dom'] = domain
result = api.domain.available(apikey, [domain])
while result[domain] == 'pending':
time.sleep(0.7)
result = api.domain.available(apikey, [domain])
if result[domain] == 'available':
resultado = domain + ' se encuentra disponible'
product_spec = {
'product' : {
'description': domain,
'type': 'domain'
},
'action' : {
'name': 'create',
'duration': duracion
}
}
result = api.catalog.list(apikey, product_spec)
result2 = result[0]
price = result2['unit_price']
price2 = price[0]
price_unit = price2['price']
precio = (price_unit + 4)*4
request.session['pr_un'] = price_unit
request.session['pre'] = precio
precio_total = precio*duracion
break
elif result[domain] == 'unavailable':
resultado = domain + ' no se encuentra disponible'
break
request.session['res'] = resultado
elif request.method == 'POST' and 'registro' in request.POST:
producto = Product()
dominio = request.session.get('dom')
dominio = str(dominio)
unit_price = request.session.get('pr_un')
sale_price = request.session.get('pre')
producto.unit_price = unit_price
producto.sale_price = sale_price
producto.num_in_stock = 30
producto.sku = Product.objects.all().count() + 1
duracion = request.session.get('dur')
producto.available = True
producto.title = dominio
producto.save()
product = ProductVariation()
product.product = producto
product.unit_price = unit_price
product.sale_price = sale_price
product.num_in_stock = 30
product.sku = ProductVariation.objects.all().count() + 1
product.save()
request.cart.add_item(product, duracion)
recalculate_cart(request)
return HttpResponseRedirect('/shop/cart/')
else:
consulta = BuscarDominioForm()
return render_to_response('buscadominioform.html',{'consulta':consulta, 'resultado':resultado, 'precio':precio_total}, context_instance=RequestContext(request))
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]])
for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_cart") is not None)
save_product = (request.method == "POST" and
request.POST.get("save_product") is not None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
quote = None
if product.custom_product:
quote_id = request.GET.get('quote_id')
if quote_id:
quote = get_object_or_404(Quote, pk=quote_id)
add_product_form = AddCustomProductForm(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart, quote=quote)
else:
add_product_form = AddProductForm(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if save_product:
user_catagory = Category.objects.get(pk=15)
new_product = product
new_images = product.images.all()
new_variations = variations
for i in new_images:
i.pk = None
i.id = None
i.save()
message = add_product_form.cleaned_data["message"]
flat_message = message.replace('\n', ' ')
new_product.pk = None
new_product.id = None
new_product.sku = None
new_product.title = trunc(s=flat_message).title() + " Canvas Print"
new_product.slug = None
new_product.custom_product = False
#new_product.available = False
new_product.content = new_product.content +flat_message
new_product.save()
new_product.categories.add(user_catagory)
new_product.images = new_images
data_uri = add_product_form.cleaned_data["image_data"]
img_str = re.search(r'base64,(.*)', data_uri).group(1)
temp_img = img_str.decode('base64')
image = ProductImage(file=ContentFile(temp_img, new_product.slug+'.png'), description = message, product=new_product)
image.save()
for v in new_variations:
v.pk = None
v.id = None
v.sku = None
v.image = image
v.save()
new_product.variations = new_variations
new_product.copy_default_variation()
json = add_product_form.cleaned_data["json_data"]
custom_product = CustomProduct(product = new_product, text = message, quote=quote, json=json)
custom_product.save()
return redirect("shop_product", slug=new_product.slug)
elif to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect("shop_cart")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": product.related_products.published(
for_user=request.user),
"add_product_form": add_product_form
}
templates = [u"shop/%s.html" % unicode(product.slug), template]
return render(request, templates, context)
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
if not request.is_ajax():
page = Category.objects.get(slug__exact='shop')
products = Product.objects.published(for_user=request.user
).filter(page.category.filters()).distinct()
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
products = paginate(products.order_by(sort_by),
request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
products.sort_by = sort_by
sub_categories = page.category.children.published()
child_categories = Category.objects.filter(id__in=sub_categories)
context = RequestContext(request, locals())
return render_to_response('pages/category.html', {}, context_instance=context)
else:
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]])
for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = AddProductForm(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
return HttpResponse(request.cart.total_quantity())
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": product.related_products.published(
for_user=request.user),
"add_product_form": add_product_form
}
templates = [u"shop/%s.html" % unicode(product.slug), template]
return render(request, templates, context)
def product(request, slug, template="shop/product.html",
form_class=AddProductForm):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart"))
return redirect(request.path)
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form,
"categories": product.categories.all()[0].get_ascendants()[::-1] + [product.categories.all()[0]]
}
# templates = [u"shop/%s.html" % str(product.slug), template]
templates = []
# Check for a template matching the page's content model.
if product.content_model is not None and product.content_model != 'product':
templates.append(u"shop/products/%s.html" % product.content_model)
context["characteristics"] = product.get_content_model().get_characteristics()
if product.content_model in ('productportal', 'productfacing'):
context["suitable_hearth"] = product.get_content_model().suitable_hearth.published(for_user=request.user)
context["suitable_topka"] = product.get_content_model().suitable_topka.published(for_user=request.user)
if product.content_model in ('producthearth', 'producttopka'):
context["suitable_faces"] = product.get_content_model().suitable_faces.published(for_user=request.user)
context["suitable_portals"] = product.get_content_model().suitable_portals.published(for_user=request.user)
templates.append(template)
return render(request, templates, context)
def product(request,
slug,
template="shop/product.html",
form_class=AddProductForm,
extra_context=None):
print "MODIFIED DEF PRODUCT"
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
to_cart = (request.method == "POST"
and request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
quantity = add_product_form.cleaned_data["quantity"]
data = add_product_form.cleaned_data
data = dict(data)
request.session['quantity'] = json.dumps(data['quantity'])
request.session['fabrics'] = str(data['fabrics'])
request.session['sku'] = str(add_product_form.variation.sku)
#checking what data/fields are stored in request.session before redirecting to other steps
# for field in request.session.iteritems():
# print "FIRST FIELD ITEM IS " + str(field)
#redirect to step 2. "tailorSelect" calls the next view and is configured in the monkeyPatch/urls.py
return HttpResponseRedirect("tailorSelect")
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
related = []
###
# fabrics = product.fabrics.all()
if settings.SHOP_USE_RELATED_PRODUCTS:
related = product.related_products.published(for_user=request.user)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": related,
"add_product_form": add_product_form,
}
context.update(extra_context or {})
templates = [u"shop/%s.html" % str(product.slug), template]
return render(request, templates, context)
def product(request, slug, template="shop/product.html"):
"""
Display a product - convert the product variations to JSON as well as
handling adding the product to either the cart or the wishlist.
"""
address = request.session['address']
if 'cart loaded' in request.session:
current_store = request.session['stores'][0]
else:
current_store = []
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=slug)
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = simplejson.dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]])
for v in variations])
to_cart = (request.method == "POST" and
request.POST.get("add_wishlist") is None)
initial_data = {}
if variations:
initial_data = dict([(f, getattr(variations[0], f)) for f in fields])
initial_data["quantity"] = 1
add_product_form = AddProductForm(request.POST or None, product=product,
initial=initial_data, to_cart=to_cart)
if request.method == "POST":
if add_product_form.is_valid():
if to_cart:
if 'cart loaded' in request.session:
current_store = Store.objects.filter(name__exact=product.store)[0]
if current_store != request.session['stores'][0]:
info(request, _("Sorry, the item cannot be added to your cart. "
"By NY law you cannot shop from two different liquor stores simultaneously."))
return HttpResponseRedirect('/shop/')
else:
request.session['cart loaded'] = 'cart loaded'
store = Store.objects.filter(name__exact=product.store)
request.session['stores'] = store
request.session['delivery min'] = store[0].delivery_min
current_store = store[0]
name = unicodedata.normalize('NFKD', current_store.name).encode('ascii','ignore')
store_slug = '/shop/'+slugify(name)+'/'
request.session['store slug'] = store_slug
quantity = add_product_form.cleaned_data["quantity"]
request.cart.add_item(add_product_form.variation, quantity)
recalculate_cart(request)
info(request, _("Item added to cart. Anything else from %s?" % name ))
# return redirect("shop_cart")
return redirect(store_slug)
else:
skus = request.wishlist
sku = add_product_form.variation.sku
if sku not in skus:
skus.append(sku)
info(request, _("Item added to wishlist"))
response = redirect("shop_wishlist")
set_cookie(response, "wishlist", ",".join(skus))
return response
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"related_products": product.related_products.published(
for_user=request.user),
"add_product_form": add_product_form,
"address": address,
"stores": current_store,
}
templates = [u"shop/%s.html" % unicode(product.slug), template] # new
return render(request, templates, context)
