def add_product(request):
if not request.user.is_authenticated:
print('dhukse')
msg = "Please Login or Register"
messages.add_message(request, messages.ERROR, msg)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
elif request.method == 'POST':
product_form = ProductForm(request.POST, request.FILES)
if product_form.is_valid():
new_product = product_form.save(commit=False)
new_product.owner = request.user
new_product.save()
msg = "Product has been added"
messages.add_message(request, messages.SUCCESS, msg)
else:
msg = "Adding Product Failed"
messages.add_message(request, messages.ERROR, msg)
"""
@send user greetings
"""
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
form = ProductForm()
return render(request, 'addproduct.html', {
'category_list': cattag,
'form': form,
'title': 'Add Product Form'
})
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):
""" 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 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():
#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 for each one.
images = []
for i in range(3):
pic = product_form.cleaned_data['image_{}'.format(i+1)]
if pic:
images.append([pic])
for pic in images:
ProductImage.objects.create(product = product,url=pic)
# 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 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 post(self, request):
form = ProductForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.save()
form = ProductForm()
return redirect('/viewPBI')
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 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':
product_form = ProductForm()
return render (
request,
'create_product.html',
context={'product_form': product_form}
)
elif request.method == '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
)
return redirect('products')
return render(
request,
'create_product.html',
context={'product_form': product_form}
)
def edit_product(request, product_id):
product = Product.objects.get(id=product_id)
if request.method == 'GET':
product_form = ProductForm(instance=product)
return render(request, 'edit_product.html', context={'product':product,'product_form': product_form})
elif request.method == 'POST':
product_form = ProductForm(request.POST, instance=product)
if product_form.is_valid():
product = product_form.save()
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)
return redirect('products')
return render(request,'edit_product.html', context={'product':product,'product_form':product_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 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_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 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 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 edit_product(request, product_id):
# Get the product with given product_id from the DB
product = ProductForm()
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
})
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.
# YOUR CODE HERE
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})
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 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 newProduct(request):
if request.method == 'POST':
form = ProductForm(request.POST)
if form.is_valid():
product = form.save(commit=False)
product.save()
return redirect('/product/productlist')
else:
form = ProductForm()
return render(request, 'products/productadd.html', {'form': form})
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 test_product_form_invalid_or_no_data(self):
form = ProductForm(data={}) #no data form
self.assertFalse(form.is_valid()) #it must not be valid
form = ProductForm(
data={
'image_link_1': 'this is not a correct link',
'title': 'There are a lot of missing entries too',
})
self.assertFalse(form.is_valid()) #it must not be valid
def image_create(request):
if request.method == 'POST':
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.save()
messages.success(request, "Successfully Created!")
return HttpResponseRedirect('/lostproducts')
else:
form = ProductForm()
context = {'form': form}
return render(request, "products/formimage.html", context)
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', {
'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)
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.
images = []
for i in range(3):
image_url = product_form.cleaned_data.get("image_{}".format(i +
1))
if image_url:
images.append(image_url)
ProductImage.objects.exclude(url__in=images).destroy()
# YOUR CODE HERE
# 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', {
'product': product,
'product_form': product_form
})
def edit(request, pk):
if request.method == "POST":
instance = get_object_or_404(Product.objects.filter(pk=pk))
form = ProductForm(request.POST, instance=instance)
if form.is_valid():
data = form.save(commit=False)
data.date_updated = datetime.datetime.now()
data.updater = request.user
data.save()
response_data = {
"status": "true",
"title": "Successfully Updated",
"message": "Product Successfully Updated.",
"redirect": "true",
"redirect_url": reverse('products:product',
kwargs={"pk": data.pk})
}
else:
message = generate_form_errors(form, formset=False)
response_data = {
"status": "false",
"stable": "true",
"title": "Form validation error",
"message": message
}
return HttpResponse(json.dumps(response_data),
content_type='application/javascript')
else:
instance = get_object_or_404(Product.objects.filter(pk=pk))
form = ProductForm(instance=instance)
context = {
"form": form,
"title": "Edit Product",
"redirect": True,
"url": reverse('products:edit', kwargs={"pk": instance.pk}),
"is_need_select_picker": True,
"is_need_popup_box": True,
"is_need_custom_scroll_bar": True,
"is_need_wave_effect": True,
"is_need_bootstrap_growl": True,
"is_need_chosen_select": True,
"is_need_grid_system": True,
"is_need_datetime_picker": True,
"is_need_animations": True,
}
return render(request, 'products/entry.html', context)
def product_new(request):
try:
restaurant = Restaurant.objects.get(manager=request.user)
except Restaurant.DoesNotExist:
messages.warning(request, "Você precisa cadastrar um restaurante")
return redirect('new_restaurant')
product_form = Product()
variations_formset = inlineformset_factory(Product,
ProductVariation,
form=ProductVariationForm,
extra=3,
max_num=3)
restaurnt_variations = Variation.objects.filter(restaurant=restaurant)
if request.method == "POST":
form = ProductForm(request.POST, instance=product_form, prefix='main')
form.fields["category"].queryset = Category.objects.filter(
restaurant__manager=request.user)
formset = variations_formset(request.POST,
instance=product_form,
prefix='product')
for formulario in formset:
formulario.fields['variation'].queryset = restaurnt_variations
if form.is_valid() and formset.is_valid():
novo_produto = form.save(commit=False)
novo_produto.restaurant = restaurant
novo_produto.save()
formset.save()
messages.success(request, "Novo produto cadastrado.")
return redirect(products_list)
else:
form = ProductForm(instance=product_form, prefix='main')
form.fields["category"].queryset = Category.objects.filter(
restaurant__manager=request.user)
formset = variations_formset(instance=product_form, prefix='product')
for formulario in formset:
formulario.fields['variation'].queryset = restaurnt_variations
return render(request, 'products/product_new.html', {
'form': form,
'formset': formset
})
def edit_product(id):
product = Products.query.filter(Products.id == id).first()
if request.method == 'POST':
form = ProductForm(formdata=request.form, obj=product)
form.populate_obj(product)
db.session.commit()
return redirect(url_for('products.index'))
form = ProductForm(obj=product)
return render_template('products/edit_product.html',
product=product,
form=form)
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 create(request):
if request.method == "POST":
form = ProductForm(request.POST)
if form.is_valid():
data = form.save(commit=False)
data.creator = request.user
data.updater = request.user
data.auto_id = get_auto_id(Product)
data.save()
response_data = {
"status": "true",
"title": "Successfully Created",
"message": "Product Successfully Created.",
"redirect": "true",
"redirect_url": reverse('products:product',
kwargs={"pk": data.pk})
}
else:
message = generate_form_errors(form, formset=False)
response_data = {
"status": "false",
"stable": "true",
"title": "Form validation error",
"message": message
}
return HttpResponse(json.dumps(response_data),
content_type='application/javascript')
else:
form = ProductForm()
context = {
"form": form,
"title": "Create Product",
"redirect": True,
"url": reverse('products:create'),
"is_need_select_picker": True,
"is_need_popup_box": True,
"is_need_custom_scroll_bar": True,
"is_need_wave_effect": True,
"is_need_bootstrap_growl": True,
"is_need_chosen_select": True,
"is_need_grid_system": True,
"is_need_datetime_picker": True,
"is_need_animations": True,
}
return render(request, 'products/entry.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 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
})
