def post(self, request):
success_message = ''
product_with_owner = Product()
product_with_owner.owner = request.user
form = ProductForm(request.POST,
request.FILES,
instance=product_with_owner)
if form.is_valid():
form.save()
success_message = '¡Producto publicado con éxito!'
context = {
'form_category':
form.data['category'],
'form_description':
form.data['description'],
'form_functionality':
form.data['functionality'],
'form_image':
format_html(
'<img src=/media/{}/{} width="230" height="200"/>'.format(
request.user, request.FILES['image'])),
'form_location':
form.data['location'],
'success_message':
success_message,
}
return render(request, 'products/newProductOk.html', context)
def editProduct(request, id):
product = get_object_or_404(Product, pk=id)
product_form = ProductForm(instance=product)
# images = ImageModelProduct.objects.all()
ImageFormset = inlineformset_factory(
Product,
ImageModelProduct,
fields=('image', ),
)
if request.method == 'POST':
product = ProductForm(request.POST, instance=product)
prod = Product.objects.get(pk=id)
formset = ImageFormset(request.POST, request.FILES, instance=prod)
if product.is_valid() and formset.is_valid():
product.save()
formset.save()
return redirect('adminView')
else:
errors = product.errors
print(errors)
return render(
request, 'admin_unnies/editproduct.html', {
'product_form': product_form,
'formset': formset,
'product': product,
})
else:
formset = ImageFormset(instance=product)
return render(request, 'admin_unnies/editproduct.html', {
'product_form': product_form,
'formset': formset,
'product': product,
})
def VersionProduct(request, pk):
# dictionary for initial data with
# field names as keys
context = {}
# fetch the object related to passed id
obj = get_object_or_404(Product, pk=pk)
#obj.photo.delete()
#obj.photo.open(mode='rb')
# pass the object as instance in form
form = ProductForm(request.POST or None, instance=obj)
# save the data from the form and
# redirect to detail_view
if form.is_valid():
obj.pk = int(round(time.time() * 1000))
#form.photo = request.POST.get('photo', False)
#form.photo = request.FILES['photo']
form.instance.creator = request.user
form.save()
return HttpResponseRedirect(reverse("products:all"))
else:
# add form dictionary to context
context["form"] = form
return render(request, "products/product_form.html", context)
def edit_product(request, product_id):
""" a view to edit a product """
if request.user.is_staff:
product = get_object_or_404(Product, pk=product_id)
if request.method == "POST":
form = ProductForm(request.POST, request.FILES, instance=product)
if form.is_valid():
form.save()
messages.success(request, f'{product.name} updated \
successfully')
return redirect(reverse('product_display', args=[product.id]))
else:
messages.error(request, 'Update product failed, please check \
the details in the form and re-submit')
else:
form = ProductForm(instance=product)
messages.info(request, f'You are editing {product.name}')
else:
messages.error(request, 'You do not have the required permissions \
for this action')
return redirect(reverse('products'))
template = 'products/edit_product.html'
context = {
'page_header': 'Edit Product',
'product': product,
'form': form,
}
return render(request, template, context)
def cadastro(request):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
return redirect('/listar')
else:
form = ProductForm()
return render(request, 'cadastro.html', {'form': form})
def product_form(request):
form = ProductForm(request.POST)
if form.is_valid():
form.save()
Product.objects.create(**form.cleaned_data)
print(form)
context = {'form': form}
return render(request, "test3.html", context)
def create_product(request):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
return redirect('list_products')
return render(request, 'products-form.html', {'form': form})
def product_create(request, *args, **kwargs):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
form = ProductForm()
context = {"form": form}
return render(request, 'product/create.html', context)
def create_product(request):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
context = {'form': form}
return render(request, 'products/create_product.html', context=context)
def product_create(request):
form = ProductForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
form.save()
return redirect('products:products')
return render(request,
"products/product_create.html",
context={"form": form})
def product_create_view(request):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
form = ProductForm() # empties form after saving
context = {
'form': form
}
return render(request, 'products/product_create.html', context)
def create(request):
if request.method == 'POST':
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
form.save()
#product.save()
return redirect('/')
return render(request, 'products/create.html', {'form': ProductForm()})
def update_product(request, id):
product = Product.objects.get(id=id)
form = ProductForm(request.POST or None, instance=product)
if form.is_valid():
form.save()
return redirect('list_products')
return render(request, 'products-form.html', {'form': form, 'product': product})
def products_create_view(request):
form = ProductForm(request.POST or None)
if form.is_valid():
form.save()
form = ProductForm()
context = {
"form": ProductForm
}
return render('create/', 'products/products_create.html', context)
def AddProducts(request):
data = {
'form': ProductForm
}
if request.method == 'POST':
form_add_product = ProductForm(data=request.POST)
form_add_product.save()
messages.success(request, 'El producto se ha guardado exitosamente')
return redirect(to='Products')
return render(request, 'products/addProducts.html', data)
def product_create(request):
form = ProductForm()
success_url = reverse_lazy("main:main")
if request.method == "POST":
form = ProductForm(request.POST)
if form.is_valid():
form.save()
return redirect(success_url)
return render(request, 'products/create.html', {'form': form})
def update(request, id):
product = Product.objects.get(id=id)
form = ProductForm(request.POST, instance=product)
if form.is_valid():
form.save()
return redirect("../../products/show")
else:
# Added else statment
msg = 'Errors: %s' % form.errors.as_text()
return HttpResponse(msg, status=400)
def productaddview(request):
if request.method == 'POST':
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('success')
else:
form = ProductForm()
return render(request, 'products/form.html', {'form': form})
def editar(request, id):
product = Product.objects.get(id=id)
form = ProductForm(request.POST, instance=product)
if form.is_valid():
form.save()
return redirect('/listar')
#else:
return render(request, 'editar.html', {'product': product})
def EditProductView(request, id):
product = get_object_or_404(Product, id=id)
data = {
'form': ProductForm(instance=product)
}
if request.method == 'POST':
form_edit_product = ProductForm(data=request.POST, instance=product)
if form_edit_product.is_valid():
form_edit_product.save()
messages.success(request, 'El producto exitosamente')
return redirect(to='Products')
return render(request, 'products/editProduct.html', data)
def edit_product(request, id):
product = Product.objects.get(id=id)
context = {'product': product, 'action': 'Editar'}
if request.method == 'POST':
product = ProductForm(request.POST, instance=product)
if product.is_valid():
product.save()
return redirect('user:home')
else:
print(product.errors)
context['form'] = product
return render(request, 'products/create_edit_product.html', context)
def create_product(request):
print('POST:', request.POST)
print('FILES:', request.FILES)
context = {}
if request.method == 'POST':
product = ProductForm(request.POST, request.FILES)
if product.is_valid():
product.save()
return redirect('user:home')
else:
print(product.errors)
context['form'] = product
return render(request, 'products/create_edit_product.html', context)
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 product_update(request, pk):
product = get_object_or_404(Product, pk=pk)
restaurant = Restaurant.objects.get(manager=request.user)
restaurnt_variations = Variation.objects.filter(restaurant=restaurant)
if request.user.is_superuser or request.user == product.restaurant.manager:
pass
else:
messages.warning(request, "Você não tem permissão.")
return redirect('dashboard')
variations_formset = inlineformset_factory(Product,
ProductVariation,
form=ProductVariationForm,
extra=3,
max_num=3)
if request.method == 'POST':
form = ProductForm(request.POST, instance=product, prefix='main')
formset = variations_formset(request.POST,
instance=product,
prefix='product')
# TODO: Aplicar queryset no formset antes.
for formulario in formset:
formulario.fields['variation'].queryset = restaurnt_variations
try:
if form.is_valid() and formset.is_valid():
form.save()
formset.save()
messages.success(request, "Produto atualizado")
return redirect('product_update', pk=pk)
except Exception as e:
messages.warning(request,
'Ocorreu um erro ao atualizar: {}'.format(e))
else:
form = ProductForm(instance=product, prefix='main')
formset = variations_formset(instance=product, prefix='product')
# TODO: Aplicar queryset no formset antes.
for formulario in formset:
formulario.fields['variation'].queryset = restaurnt_variations
return render(request, 'products/product_update.html', {
'form': form,
'formset': formset,
})
def products(request):
products = Products.objects.all()
form = ProductForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
else:
form = ProductForm()
return render(request, "products.html", context={
"products": products,
"form": form
})
def product_update(request, pk):
product = get_object_or_404(Product, pk=pk)
form = ProductForm(request.POST or None, instance=product)
if request.method == "POST":
if form.is_valid():
form.save()
messages.success(request, "Sucesso!")
return redirect(
reverse('products:product_update', kwargs={"pk": pk}))
return render(request,
"products/product_update.html",
context={
"form": form,
"product": product
})
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 product_edit(request, *args, **kwargs):
# Initial data is used when you want a form input to have a default value
#
# initial_data = {
# "price": 10
# }
# form = ProductForm(request.POST or None,initial=initial_data)
product = Product.objects.get(id=1)
form = ProductForm(request.POST or None, instance=product)
if form.is_valid():
form.save()
context = {"form": form}
return render(request, 'product/edit.html', context)
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 detail(request, product_id):
products = Product.objects.all()
product_id = int(product_id)
form = ProductForm(
initial={
'name': Product.objects.get(id=product_id).name,
'quantity': Product.objects.get(id=product_id).quantity,
'description': Product.objects.get(id=product_id).description,
'skq': Product.objects.get(id=product_id).skq,
'category': Product.objects.get(id=product_id).category,
'brand': Product.objects.get(id=product_id).brand,
'purchases': Product.objects.get(id=product_id).purchases,
'serial': Product.objects.get(id=product_id).serial,
'unit_cost': Product.objects.get(id=product_id).unit_cost,
'selling_price': Product.objects.get(id=product_id).selling_price,
'rack_location': Product.objects.get(id=product_id).rack_location,
'notes': Product.objects.get(id=product_id).notes,
})
form_post = ProductForm(request.POST)
if form_post.is_valid():
form_post.auto_id = product_id
profile = form_post.save()
profile.pk = product_id
profile.save()
context = {
'products': products,
'product_id': product_id,
"product_form": form
}
return render(request, 'products/product-details.html', context)
def edit_product(request, product_id):
# Get the product with given product_id from the DB
product = get_object_or_404(Product, 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_form': product_form, 'product': product})
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():
product = product_form.save()
urls = [request.POST.get(url) for url in ['image_{}'.format(i) for i in range(1,4)] if request.POST.get(url)]
# Delete unneeded images.
product_images = product.productimage_set.all()
product_images.exclude(url__in=urls).delete()
# Create needed images.
# Calling bulk_create() would be better if we know which ones we need to create.
for url in urls:
product_images.get_or_create(product=product, url=url)
return redirect('products')
return render(request, 'edit_product.html', context={'product_form': product_form, 'product': product})
def create_product(request):
if request.method == 'GET':
# Create an empty instance of ProductFrom() and render "create_product.html"
# sending the form as context under "product_form" key
product_form = ProductForm()
return render(request,
'create_product.html',
context={'product_form': product_form})
elif request.method == 'POST':
# Create an instance of ProductFrom initializing it with the product
# data that come in request.POST
product_form = ProductForm(request.POST)
if product_form.is_valid():
product = product_form.save()
images = []
for i in range(3):
image = product_form.cleaned_data['image_{}'.format(i + 1)]
if image:
images.append(image)
for image in 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_form as context, which will have all the error messages included
return render(request,
'create_product.html',
context={'product_form': product_form})
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 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))
