def saveProduct(request):
if request.method == 'POST' and request.user.is_authenticated():
productForm = ProductForm(request.POST, prefix='product')
if productForm.is_valid():
category_form = CategoryForm(data=request.POST, prefix='category')
if category_form.is_valid():
producto = saveProductData(request, productForm)
imageForm = ImagesForm(request.POST,request.FILES, prefix='image')
if imageForm.is_valid():
producto.save()
saveCategoryData(producto, category_form)
saveAlbumData(producto, request.user.id)
saveImages(request, producto.img)
puntos = Point.objects.get(action="new_product")
profile = request.user.profile
profile.quds = profile.quds + int(puntos.qty)
profile.save()
else:
return HttpResponse("NO FILES")
return HttpResponseRedirect("/products/" + str(producto.id))
else:
return HttpResponse("CATEGORY FAIL")
else:
return HttpResponse("INVALID PRODUCT")
return HttpResponse("FAIL")
def add_product(request, product_id=None):
product = Product.objects.get(product_id=product_id)
if request.method == "POST":
productform = ProductForm(request.POST, instance=product)
if productform.is_valid():
product = productform.save()
return HttpResponseRedirect(product.get_absolute_url())
else:
productform = ProductForm(instance=product)
return render(request, "add_product.html", {"form": productform})
def viewCreate(request):
if request.POST:
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/home/')
else:
form = ProductForm()
c = {}
c.update(csrf(request))
c['form'] = form
return render_to_response('createproduct.html', context_instance=RequestContext(request, c))
def add(request):
if request.POST:
form = ProductForm(request.POST)
if form.is_valid():
form.save()
# If the save was successful, redirect to another page
redirect_url = reverse('products:list')
return HttpResponseRedirect(redirect_url)
else:
form = ProductForm()
content = {'title': 'Add new product', 'form': form}
context_instance = RequestContext(request)
return render_to_response('products/form.html', content, context_instance)
def viewUpdate(request, pk):
id = pk
if request.POST:
products.objects.filter(id=id).delete()
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/home/')
else:
form = ProductForm()
c = {}
c.update(csrf(request))
c['id'] = id
c['form'] = form
return render_to_response('update.html', context_instance=RequestContext(request, c))
def home(request):
recents = Product.objects.filter(image_url__isnull=False).order_by('-created')[:6]
term = None
if request.method == 'POST':
productform = ProductForm(request.POST)
if productform.is_valid():
code = productform.cleaned_data['ASIN']
asin = re.compile("^B\d{2}\w{7}|\d{9}(X|\d)$")
if asin.match(code):
product = amazon_utils.get_or_create_product(code)
else:
asin, term = amazon_utils.random_product(code)
while not asin and not term:
time.sleep(1.5)
asin, term = amazon_utils.random_product()
product = amazon_utils.get_or_create_product(asin)
ean = product.generate_barcode(type='ean13')
upc = product.generate_barcode(type='upca')
qrcode = product.generate_barcode(type='qrcode', text=False)
return render_to_response('labels/generator_output.html',
{
'product': product,
'ean': ean,
'upc': upc,
'qrcode': qrcode,
'search_term': term,
},
context_instance=RequestContext(request))
else:
productform = ProductForm()
return render_to_response('labels/home.html',
{
'product_form': productform,
'recents': recents,
},
context_instance = RequestContext(request))
def add_or_edit(request, id=None):
if id:
product = get_object_or_404(Product, pk=id)
action = "Edit "
else:
product = Product()
action = "Add a new "
if request.POST:
form = ProductForm(request.POST, instance=product)
if form.is_valid():
form.save()
# If the save was successful, redirect to another page
redirect_url = reverse('products:list')
return HttpResponseRedirect(redirect_url)
else:
form = ProductForm(instance=product)
content = {'title': action + 'product', 'form': form}
context_instance = RequestContext(request)
return render_to_response('products/form.html', content, context_instance)
def ManageCatalogView(request, shopid):
if not request.user.groups.filter(name='shopadmin'):
return HttpResponse("invalid group")
template_name = "shops/manageCatalog.html"
context = {}
#check shop access perms
try:
shop = Shop.objects.get(id = shopid)
if not shop.shop_admin.id == request.user.id:
raise Exception
except:
return HttpResponse("The requested shop does not exist or is inaccessible for this current shopadmin.")
product_form = None
catalog_form = None
context["shop"] = shop
if request.method == 'POST':
if request.GET.get("catalog_form") and int(request.GET.get("catalog_form")) == 2: #submitted
print "catalog form submitted"
catalog_form = ShopAdminCatalogForm(data=request.POST)
if catalog_form.is_valid():
catalog_item = catalog_form.save(commit = False)
catalog_item.shop = shop
catalog_item.save()
print "catalog item saved"
catalog_form = None
elif request.GET.get("product_form") and int(request.GET.get("product_form")) == 2: #submitted
print "product form submitted"
product_form = ProductForm(data=request.POST)
if product_form.is_valid():
product_form.save()
print "new product saved"
product_form = None
else:
catalog_item_id_delete = request.GET.get("del")
display_catalog_form = (request.GET.get("catalog_form"))
display_product_form = (request.GET.get("product_form"))
if catalog_item_id_delete:
catalog_item = Catalog.objects.filter(id = catalog_item_id_delete)
catalog_item.delete()
if display_catalog_form:
if int(display_catalog_form) == 1:
catalog_form = ShopAdminCatalogForm()
if display_product_form:
if int(display_product_form) == 1:
product_form = ProductForm()
print catalog_item_id_delete
print display_catalog_form
print display_product_form
context['catalog_form'] = catalog_form
context['product_form'] = product_form
#get list of shops owned
catalog = shop.catalog_set.all()
context['catalog'] = catalog
#get list of shops owned
shops = request.user.shop_set.all()
context['shops'] = shops
#shop ID part
if shopid == None:
shops = request.user.shop_set.all()
if shops:
shop = shops[0]
else:
shop = None
#test that perms for specified shop exists
else:
try:
shop = Shop.objects.get(id = shopid)
if not shop.shop_admin.id == request.user.id:
raise Exception
except:
return HttpResponse("The requested shop does not exist or is inaccessible for this current shopadmin.")
context["shop"] = shop
return render_to_response(template_name, context, context_instance=RequestContext(request))
def my_calories_view(request):
message = ""
message_color = ""
recommendation = ""
recommendation_less_list = [
"Spożywasz zbyt dużo kalorii",
"Zalecamy przejście na jedzenie o niższej kaloryczności",
"Zwróć uwagę na to, co jesz, zawiera za dużo kalorii"
]
recommendation_normal_list = [
"Spożywasz dostateczną ilość kalorii", "Doskonale przestrzegasz diety",
"Czieszymy się że spożywasz odpowiednią liczbę kalorii"
]
recommendation_more_list = [
"Powinieneś jeść więcej wysokokalorycznych potraw",
"Musisz spożywać więcej kalorii",
"Zalecamy spożywanie większej ilości kalorii"
]
daily_norm_min = 1700
daily_norm_max = 2600
user_calories = Calories.objects.filter(
user=request.user).order_by("-date")
product_form = ProductForm()
calories_form = CaloriesForm()
# Adding products to base
if request.method == 'POST':
product_form = ProductForm(request.POST)
if product_form.is_valid():
name = product_form.cleaned_data['name']
caloric_content = product_form.cleaned_data['caloric_content']
try:
Product.objects.get(name=name.lower(),
caloric_content=caloric_content)
message = "Produkt już istnieje w bazie"
message_color = "#FFF3CD"
except ObjectDoesNotExist:
Product.objects.create(name=name.lower(),
caloric_content=caloric_content)
message = "Produkt został dodany do bazy"
message_color = "#D4EDDA"
else:
product_form = ProductForm()
# Adding products to user list
if request.method == 'POST':
calories_form = CaloriesForm(request.POST)
if calories_form.is_valid():
product = calories_form.cleaned_data['product']
weight = calories_form.cleaned_data['weight']
product = product.lower()
try:
db_product = Product.objects.get(name=product)
Calories.objects.create(user=request.user,
product=db_product,
weight=weight)
message = "Produkt został dodany"
message_color = "#D4EDDA"
except ObjectDoesNotExist:
message = "Produkt nie istnieje w bazie"
message_color = "#F8D7DA"
else:
calories_form = CaloriesForm()
today_min = datetime.datetime.combine(datetime.date.today(),
datetime.time.min)
today_max = datetime.datetime.combine(datetime.date.today(),
datetime.time.max)
try:
today_calories = Calories.objects.filter(user=request.user,
date__range=(today_min,
today_max))
today_calories_sum_dict = today_calories.aggregate(Sum('calories_sum'))
try:
today_calories_sum = int(
today_calories_sum_dict.get("calories_sum__sum"))
except TypeError:
today_calories_sum = 0
if today_calories_sum >= daily_norm_min and today_calories_sum <= daily_norm_max:
recommendation = recommendation_message(recommendation_normal_list)
elif today_calories_sum < daily_norm_min:
recommendation = recommendation_message(recommendation_more_list)
elif today_calories_sum > daily_norm_max:
recommendation = recommendation_message(recommendation_less_list)
except ObjectDoesNotExist:
recommendation = ""
context = {
'product_form': product_form,
'user_calories': user_calories,
'calories_form': calories_form,
'message': message,
'message_color': message_color,
'recommendation': recommendation
}
template = "users/user_calories.html"
return render(request, template, context)
def test_rating_is_required(self):
form = ProductForm({'rating': ''})
self.assertFalse(form.is_valid())
def edit_product(request, product_id):
# Get the product with given product_id from the DB
product = Product.objects.get(id=product_id)
if request.method == 'GET':
# Create an instance of ProductForm sending the product in the "instance"
# parameter. This will initialize all the fields in the form with the
# data from our product.
product_form = ProductForm(instance=product)
# Render the 'edit_product.html' template sending the product and the
# product_form as context
return render(request,
'edit_product.html',
context={
'product': product,
'product_form': product_form
})
elif request.method == 'POST':
# Create an instance of ProductForm sending the new data that come in
# request.POST, and also the product inside the "instance" parameter
product_form = ProductForm(request.POST, instance=product)
if product_form.is_valid():
# Create the product object while saving the form
product = product_form.save()
# Inside product_form.cleaned_data you will find the already
# validated data for the product. Use the images urls there to
# create a ProductImage object that are not already created in the DB.
# The ones that didn't come in cleaned_data and are stored in the DB
# should be deleted.
new_images = []
for i in range(3):
image = product_form.cleaned_data['image_{}'.format(i + 1)]
if image:
new_images.append(image)
old_images = [
image.url for image in product.productimage_set.all()
]
images_to_delete = []
for image in old_images:
if image not in new_images:
images_to_delete.append(image)
ProductImage.objects.filter(url__in=images_to_delete).delete()
for image in new_images:
if image not in old_images:
ProductImage.objects.create(product=product, url=image)
# Redirect to 'products' view
return redirect('products')
# If form is not valid, re-render the 'create_product.html' sending the
# product and the product_form as context
return render(request,
'create_product.html',
context={
'product': product,
'product_form': product_form
})
