def register(response):
if response.method=="POST":
form = RegisterForm(response.POST)
first_name=response.POST['first_name']
last_name=response.POST['last_name']
username=response.POST['email']
password1=response.POST['password1']
password2=response.POST['password2']
email=response.POST['email']
if User.objects.filter(email=email).exists():
messages.danger(response,'Email Already Exists')
return redirect('register')
elif password1!=password2:
messages.danger(response,'Passwords do not match')
return redirect('register')
elif form.is_valid():
user=User.objects.create_user(username=username,password=password1,email=email,first_name=first_name,last_name=last_name)
user.save()
messages.success(response,'Account created Successfully')
print(messages)
return redirect("login")
else:
if response.user.is_authenticated == True:
return redirect('index')
form = RegisterForm()
return render(response, "accounts/register.html", {"form":form})
def remove_from_bag(request, item_id):
"""Remove the item from the shopping bag"""
try:
product = get_object_or_404(Product, pk=item_id)
size = None
if 'product_size' in request.POST:
size = request.POST['product_size']
bag = request.session.get('bag', {})
if size:
del bag[item_id]['items_by_size'][size]
if not bag[item_id]['items_by_size']:
bag.pop(item_id)
messages.success(
request,
f'Removed size {size.upper()} {product.name} from your bag')
else:
bag.pop(item_id)
messages.success(request, f'Removed {product.name} from your bag')
request.session['bag'] = bag
return HttpResponse(status=200)
except Exception as e:
messages.danger(request, f'Error removing item {e}')
return HttpResponse(status=500)
def get(self, *args, **kwargs):
transaction = Transaction(
authorization_key='sk_test_4efc8832170a975a1e1eb669a89b512909d0049a'
)
response = transaction.verify(kwargs['id'])
data = JsonResponse(response, safe=False)
if response[3]:
try:
order = Order.objects.get(user=self.request.user,
ordered=False)
payment = Payment()
payment.paystack_id = kwargs['id']
payment.user = self.request.user
payment.amount = order.get_total()
payment.save()
order_items = order.items.all()
order_items.update(ordered=True)
for item in order_items:
item.save()
order.ordered = True
order.payment = payment
order.ref_code = create_ref_code()
order.save()
messages.success(self.request, "order was successful")
return redirect("/")
except ObjectDoesNotExist:
messages.success(self.request, "Your order was successful")
return redirect("/")
else:
messages.danger(self.request, "Could not verify the transaction")
return redirect("/")
def processOrder(request):
customer = request.user.customer
order, created = Order.objects.get_or_create(customer=customer,
complete=False)
if order.no_of_orders > 20:
messages.danger(
request, "Today's order number quota is exceeded for " +
str(customer.name) + ".")
return JsonResponse({"msg": "not succeeded"})
data = json.loads(request.body)
print(data)
date = data['date'].split("-")
time = data['time'].split(":")
datetime_ = datetime.datetime(int(date[0]), int(date[1]), int(date[2]),
int(time[0]), int(time[1]), 0, 0)
transaction_id = datetime.datetime.now().timestamp()
customer = request.user.customer
order, created = Order.objects.get_or_create(customer=customer,
complete=False)
order.transaction_id = transaction_id
order.pickup_date_time = datetime_
order.no_of_orders = order.no_of_orders + 1
total = order.get_cart_total
order.complete = True
order.save()
messages.success(
request,
"Order is confirmed for " + str(customer.name) +
f". Your pickup time is {order.pickup_date_time} and be ready with your cash !",
)
return JsonResponse({"msg": "success"})
def contact_details(request):
"""Collect email and running club and add to session"""
user = request.user
basket = request.session.get('basket', {})
if not basket:
messages.danger(request, "You don't have any thing in your basket.")
return redirect(reverse('all_shoes'))
if user.is_authenticated:
contact_details = {
'email': user.email,
'running_club': user.profile.running_club
}
contact_form = ContactDetailsForm(request.POST or contact_details)
if request.method == "POST":
if contact_form.is_valid():
request.session['email'] = contact_form.cleaned_data['email']
request.session['running_club'] = contact_form.cleaned_data[
'running_club']
return redirect(reverse('delivery_details'))
else:
contact_details = {
'email': request.session.get('email', None),
'running_club': request.session.get('running_club', None)
}
contact_form = ContactDetailsForm(request.POST or contact_details)
if request.method == "POST":
if contact_form.is_valid():
request.session['email'] = contact_form.cleaned_data['email']
request.session['running_club'] = contact_form.cleaned_data[
'running_club']
return redirect(reverse('delivery_details'))
return render(request, 'contact_details.html',
{'contact_form': contact_form})
def update_source(request):
if request.method == "POST":
if request.user.is_authenticated:
try :
user = User.objects.get(username = request.user)
except:
messages.error(request, "Unknown Error, Please Contact Admin")
return redirect('index')
source_id = request.POST['source_id']
amt = request.POST['new_amt']
source = Source.objects.get(id=source_id)
record = Record.objects.create(user = user, source=source, amount = amt )
messages.success(request, f"{source.name} has been updated to ${record.amount}")
return redirect('index')
else:
messages.danger('You need to be logged in')
return redirect('index')
else:
messages.danger(request,'Wrong method used to enter this page')
return redirect('index')
def index(req):
tasks_approved = models.Pkl.objects.filter(owner=req.user,
approve=True).first()
tasks = models.Pkl.objects.filter(owner=req.user)
# ambil tanggal mulai
# tanggal mulai ditamnah 3 bulan
# ambil tanggal selesai
# checked pake if apakah tanggal selesai lebih dari hasil dari tanggal yang ditentukan
# untuk menentukan kapan mulainya maka harus ada pengecekan di bagian home
form_input = forms.PklForm()
if req.POST:
form_input = forms.PklForm(req.POST, req.FILES)
if form_input.is_valid():
form_input.instance.owner = req.user
form_input.save()
messages.success(req, 'Data telah ditambahkan.')
return redirect('/mahasiswa')
else:
messages.danger(
req, 'A problem has been occurred while submitting your data.')
# group = req.user.groups.first()
# if group is not None and group.name == 'staf':
# tasks = models.Pkl.objects.all()
return render(req, 'mahasiswa/index.html', {
'form': form_input,
'data': tasks,
'data_approved': tasks_approved,
})
def source_view(request,id):
if request.user.is_authenticated:
try :
user = User.objects.get(username = request.user)
except:
messages.error(request, "Unknown Error, Please Contact Admin")
return redirect('index')
source = Source.objects.get(id=id)
if source.user == user:
print(source)
src_labels = []
src_amt = []
for record in source.records.all():
src_labels.append(record.date_added.strftime("%Y-%m-%d"))
src_amt.append(int(record.amount))
return render(request,'source_view.html',{'source':source, 'src_labels':src_labels, 'src_amt':src_amt})
else:
messages.error(request,'You are not authorized to view this source')
return redirect('index')
else:
messages.danger(request,'You need to be logged in')
return redirect('index')
def polls(request, id):
if request.method == "GET":
context = {}
try:
question = Question.objects.get(id=id)
except:
raise Http404
context['title'] = 'Vote | ' + question.title
context['question'] = question
return render(request, 'poll/poll.html', context)
if request.method == "POST":
user_id = request.user.id
data = request.POST
question = Question.objects.get(id=id)
ans = Answer.objects.filter(user_id=user_id, question_id=question.id)
if ans:
messages.warning(request, 'Your Vote already submitted')
return redirect('polls_list')
else:
ret = Answer.objects.create(user_id=user_id,
choice_id=data['choice'],
question_id=question.id)
if ret:
messages.success(request, 'Your Vote submitted Succesfully')
return redirect('polls_list')
else:
messages.danger(request, 'Vote not Submitted')
return redirect('polls_list')
def remove_one_from_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_item, created = OrderItem.objects.get_or_create(
item=item,
user=request.user,
ordered=False,
)
order_qs = Order.objects.filter(user=request.user, ordered=False)
if order_qs.exists():
order = order_qs[0]
if order.items.filter(item__slug=item.slug).exists():
if order_item.quantity > 1:
order_item.quantity -= 1
order_item.save()
else:
order.items.remove(order_item)
order_item.delete()
messages.success(request, "Item quantity updated!")
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
else:
messages.warning(request, "Item is not in your cart!")
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
else:
messages.danger(request, "You do not have an active order!")
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def index(req):
tasks_approved = models.Pkl.objects.filter(owner=req.user,approve=True).first()
tasks = models.Pkl.objects.filter(owner=req.user)
form_input = forms.PklForm()
if req.POST:
form_input = forms.PklForm(req.POST, req.FILES)
if form_input.is_valid():
form_input.instance.owner = req.user
form_input.save()
messages.success(req, 'Data telah ditambahkan.')
return redirect('/mahasiswa')
else:
messages.danger(req, 'A problem has been occurred while submitting your data.')
# group = req.user.groups.first()
# if group is not None and group.name == 'staf':
# tasks = models.Pkl.objects.all()
return render(req, 'mahasiswa/index.html',{
'form' : form_input,
'data': tasks,
'data_approved': tasks_approved,
})
def logout_page(request):
try:
logout(request)
messages.danger(request, f"Logged out successfully!")
except Exception as e:
logging.info(e)
return redirect('login-route')
def cart_checkout(request):
cart = Cart(request)
if (cart.cart):
quantity = []
amount = []
purchased_products = []
for i in cart.cart:
print(i, cart.cart[i]['quantity'], cart.cart[i]['price'])
purchased_products.append(i)
quantity.append(cart.cart[i]['quantity'])
amount.append(int(cart.cart[i]['price']))
amount = [amount[i] * quantity[i] for i in range(len(amount))]
amount.append(sum(amount))
quantity = [str(i) for i in quantity]
amount = [str(i) for i in amount]
order = Order(user=User.objects.get(id=request.user.id),
products=purchased_products,
quantity=quantity,
amount=amount)
order.save()
cart.clear()
messages.success(request, 'Sucessfully Purchased')
else:
messages.danger(request, 'Cart is empty')
return redirect('cart_detail')
return redirect("products")
def delete(self, request, *args, **kwargs):
self.atenciones = Atenciones.objects.get(atencion=self.kwargs['pk'])
try:
d = self.get_object()
deps, msg = get_dep_objects(d)
print(deps)
if deps:
messages.warning(
self.request, ('No se puede eliminar %(name)s)') % {
"name":
capfirst(force_text(self.model._meta.verbose_name)) +
'"' + force_text(d) + '"'
})
raise Exception(msg)
d.delete()
msg = (' %(name)s "%(obj)s" fue eliminado satisfactoriamente.') % {
'name': capfirst(force_text(self.model._meta.verbose_name)),
'obj': force_text(d)
}
if not d.id:
messages.success(self.request, msg)
except Exception as e:
messages.danger(request, e)
return HttpResponseRedirect(self.get_success_url())
def marketplace_ad_delete_confirm(request,slug):
ad = Advert.objects.get(slug = slug)
if(ad.user != request.user):
messages.danger(request,f'Illegal Action!')
return redirect('marketplace:marketplace-index')
else:
return render(request,'marketplace/marketplace-ad-delete-confirm.html',{'ad':ad})
def comment_delete(request, article_id, comment_id):
if request.user.is_authenticated:
comment = Comment.objects.get(id=comment_id)
if comment.user == request.user:
comment.delete()
return redirect('articles:comments', article_id)
else:
messages.danger(request,
'You do not have permission to delete this comment.')
return redirect('accounts:login')
def notify_user(request):
if request.method == 'POST':
form = NotifyForm(request.POST)
if form.is_valid:
form.save()
return redirect('message')
messages.danger(request, "Notification has been sent")
else:
form = NotifyForm()
return render(request, "admin/notify.html", {"form":form})
def delete_user(request, user_ret):
user_del = User.objects.filter(username=user_ret).first()
if user_del is not None:
print(user_del)
user_del.delete()
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
# return redirect('welcome')
else:
messages.danger('User not found')
return redirect('welcome')
def new_package(request):
if request.method == 'POST':
form = PackagesForm(request.POST)
if form.is_valid:
form.save()
return redirect('admin-package')
messages.danger(request, "Package added")
else:
form = PackagesForm()
return render(request, 'admin/new-package.html',{"form": form})
def add_users_list(request, school, roley):
school = get_object_or_404(School, slug=school)
# roley = get_object_or_404(Role, id=roley)
font_image = "fa fa-plus-square"
heading_title = "Add employee"
h3 = "Employees"
h4 = "All users you create, they will have the same default password, 'password'"
go_home = "home"
show_hidden = "hidden"
connected_user = get_object_or_404(User, pk=request.user.id)
rolee = get_object_or_404(Role, url="director")
check_user = Attribution.objects.filter(school=school.id,
user=connected_user.id,
role=rolee.id).count()
all_attributions = Attribution.objects.all()
search_role = Role.objects.all()
if check_user == 1:
if request.method == "POST":
form = AddUsersForm(request.POST, request.FILES)
if form.is_valid():
try:
j = load_users(school, roley,
request.FILES['allusers_list'])
if not j:
messages.error(request, "List is already loaded")
show_hidden = "show"
home = "home"
btn_class = "btn btn-lg btn-primary mt-5 btn-block"
back = "Go back home"
if j:
messages.success(
request,
"List of employees is loaded successfully!")
return redirect(view_employee_view, school.slug)
except OSError:
messages.error(request, "Format not supported!")
except NameError:
messages.error(request, "Format not supported!")
# except BadZipFile:
# messages.error(request,"Format not supported!")
else:
messages.error(request,
"In list, some usernames is already used!")
form = AddUsersForm(request.FILES)
else:
messages.danger(request, "Something went wrong!")
return redirect(add_user_view, school)
return render(request, 'add_users.html', locals())
def marketplace_ad_delete(request,slug):
ad = Advert.objects.get(slug = slug)
if(ad.user != request.user):
messages.danger(request,f'Illegal Action!')
else:
Advert.objects.filter(slug = slug).delete()
messages.success(request,f'Ad Deleted')
return redirect('marketplace:marketplace-index')
def delete_product(request, pk):
if request.user.is_superuser:
product = Product.objects.filter(pk=pk)
if product.exists():
product.delete()
messages.info(request, 'Item Has Been Deleted')
return redirect(reverse('adminpage-list_product'))
else:
messages.danger(request, 'Item Cant Be Deleted')
return redirect(reverse('adminpage-list_product'))
else:
return redirect(reverse('adminpage-index'))
def marketplace_ad_contact_seller(request,slug):
ad = Advert.objects.get(slug = slug)
if(ad.user == request.user):
messages.danger(request,f'Illegal Action!')
else:
seller = User.objects.get(username = ad.user)
user = request.user
ads = Advert.objects.filter(user = seller)
Notify.objects.create(user = seller, buyer = user, product = ad)
messages.success(request,f'Seller Notified about your interest!')
return render(request,'marketplace/marketplace-user.html',{'user':seller,'ads':ads})
def delete_post(request, sl_no):
if request.user.is_authenticated:
current_user = request.user
del_post = Post.objects.get(sno=sl_no)
if del_post.author == current_user:
del_post.delete()
messages.success(request, 'Post got deleted!!')
else:
messages.warning(request, 'You are not authorized...')
else:
messages.danger(request, 'Invalid Attempt!!')
return redirect('/blog/manage_post')
def form_valid(self, form):
limite_mb = 3 * 1024 * 1024
obj = form.instance
if (not obj.arquivo_foto or
(obj.arquivo_foto and obj.arquivo_foto.file.size <= limite_mb)):
form.save()
return super(ObjetoUpdateView, self).form_valid(form)
else:
messages.danger(self.request,
'Sistema somente suporta 3 Mb na foto!')
return super(ObjetoUpdateView, self).form_invalid(form)
def delete_lead(request, pk):
lead = get_object_or_404(Lead, master_user=request.user.user_master, pk=pk)
try:
lead.delete()
messages.success(request, 'Registro removido com sucesso !')
except:
messages.danger(
request,
'Registro vinculado a movimentações, exclusão não ocorreu!')
return redirect('leads_lista')
def post(self, request, **kwargs):
user_pk = request.POST['user_pk']
user = get_object_or_404(User, pk=user_pk)
if user.profile.team == None:
team = Team.objects.get(pk=kwargs.get('pk'), slug=kwargs.get('slug'))
role = Role.objects.get(name='Team Member')
user.profile.team = team
user.profile.role = role
user.profile.save()
messages.success(request, f'{user.username} er nu tilføjet til {team.name} som elev!')
else:
messages.danger(request, f'{user.username} er allerede på et hold, og kan derfor ikke tilføjes.')
return redirect(reverse('team-add-user', kwargs=kwargs))
def cadastro_produto(request):
if request.method == 'POST':
form = cadastrar_produto(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('estoque:estoque_produtos'))
else:
messages.danger(request, 'erro na adição do produto')
return HttpResponseRedirect(reverse('estoque:cadastro_produto'))
contexto= {
'form':cadastrar_produto()
}
return render(request, "cadastro_produto.html", contexto)
def deleterequest(request, request_id):
users_in_group = Group.objects.get(name="Librarian").user_set.all()
if request.user in users_in_group:
reqrequest = IssueRequest.objects.get(request_id=request_id)
if request.method == 'POST':
reqrequest.delete()
return redirect("/viewrequests")
messages.danger(request, "Request Deleted !")
context = {'reqrequest': reqrequest}
return render(request, 'librarymanager/viewrequests.html', context)
else:
return redirect('/libview')
def assign_assignment(request, obj):
try:
username = request.GET.get('to', None)
if username:
user = User.objects.get(username=username)
else:
user = None
except User.DoesNotExist:
messages.danger(request, _("Could not assign task to {}, no such user exists.").format(username));
return JsonResponse(make_failure("No user named {}".format(username)))
else:
obj.assignee = user
obj.save()
return JsonResponse(make_success())
def create_profile(request):
form = forms.UserProfileForm()
if request.method == 'POST':
form = forms.UserProfileForm(request.POST, request.FILES)
if form.is_valid():
try:
profile = form.save(request.user)
messages.success(request, 'Profile created successfully')
return HttpResponseRedirect(reverse('home'))
except Exception as e:
messages.danger(request,
'Error creating profile: {}'.format(e))
return HttpResponseRedirect(reverse('accounts:create_profile'))
return render(request, 'accounts/create_profile.html', {'form': form})
def destroy_product(request, product_id):
#order = Order.objects.filter(product_id=product_id).count()
#if order > 0:
# return redirect('/products', messages.success(request, 'Cannot delete product while its order exists.', 'alert-danger'))
#else:
# product = Product.objects.get(id=product_id)
# product.delete()
# return redirect('/products', messages.success(request, 'Product was successfully deleted.', 'alert-success'))
if Product.objects.filter(id=product_id).update(active='0'):
return redirect('/products', messages.success(request, 'Product was successfully deleted.', 'alert-success'))
else:
return redirect('/products', messages.danger(request, 'Cannot delete product while its order exists.', 'alert-danger'))
