def addtocart(request):
global design_summary
global context
if design_summary.size is None and design_summary.shirtfit is not None and design_summary.standard_size is None:
sweetify.warning(request, 'Measurement is a neccessary field')
return redirect('/selection/select/MSIZE/MSIZE/', context)
if design_summary.size is None and design_summary.shirtfit is None and design_summary.standard_size is not None:
sweetify.warning(request, 'Measurement is a neccessary field')
return redirect('/selection/select/MSIZE/MSIZE/', context)
if design_summary.size is None and design_summary.shirtfit is None and design_summary.standard_size is None:
sweetify.warning(request, 'Measurement is a neccessary field')
return redirect('/selection/select/MSIZE/MSIZE/', context)
if request.user.is_authenticated:
if design_summary.cloth_menu == None:
sweetify.warning(request, 'Should select a cloth type')
return redirect('/selection/select', context)
design_summary.user = request.user
design_summary.quantity = 1
design_summary.subtotal = design_summary.quantity * design_summary.cloth_menu.price
design_summary.status = OrderStatusCode.objects.get(status='INCART')
design_summary.save()
design_summary = Orders()
sweetify.success(request, 'Item added to cart.')
return redirect('/cart/')
else:
sweetify.warning(request, 'Login is required')
return render(request, 'login_page.html', context)
def add(request):
try:
form = AddMachineForm(request.POST or None)
form_ipmi = PowerTypeIPMIForm(request.POST or None)
if form.is_valid() and form_ipmi.is_valid():
data = form.clean()
ipmi_data = form_ipmi.clean()
data.update({'commission': False, 'power_parameters': ipmi_data})
maas = MAAS()
resp = maas.post("machines/", data=data)
if resp.status_code in maas.ok:
sweetify.success(request,
_('Successfully added domain'),
button='Ok',
timer=2000)
return redirect("maas:machines:index")
sweetify.warning(request, _(resp.text), button='Ok', timer=10000)
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request,
'Warning',
icon='error',
text=str(e),
button='OK',
timer=10000)
form = None
form_ipmi = None
context = {'title': 'Add Machine', 'form': form, 'form_ipmi': form_ipmi}
return render(request, "maas/machines/add-form.html", context)
def edit(request, id):
try:
maas = MAAS()
domain = maas.get(f"domains/{id}/").json()
form = EditDomainForm(request.POST or None, initial=domain)
if form.is_valid():
resp = form.save(domain['id'])
if resp.status_code in maas.ok:
sweetify.sweetalert(request,
'Success',
text=_('Successfully edited domain'),
button='Ok',
timer=2000)
return redirect("maas:dns:index")
sweetify.warning(request, _(resp.text), button='Ok', timer=2000)
context = {
'title': 'Edit Domain',
'menu_active': 'domains',
'form': form,
'title_submit': 'Save Domain',
'col_size': '4'
}
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request,
'Warning',
text=str(e),
button='Ok',
timer=5000)
context = None
return render(request, 'maas/form.html', context)
def form_invalid(self, form):
warning(self.request,
'Verifique la información ingresada.',
toast=True,
position='top',
timer=3000)
return super(Edit, self).form_invalid(form)
def form_invalid(self, form):
warning(self.request,
'¡Verifique la información ingresada!',
toast=True,
position='top',
timer=3000)
return self.render_to_response(self.get_context_data(form=form))
def add(request):
form = AddDomainForm(request.POST or None)
if form.is_valid():
try:
resp = form.save()
if resp.status_code == requests.codes.ok:
sweetify.sweetalert(request,
icon='success',
text=_('Successfully added domain'),
button='Ok',
timer=2000)
return redirect("maas:dns:index")
sweetify.warning(request,
_('Terjadi suatu kesalahan'),
button='Ok',
timer=2000)
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request,
'Warning',
text=str(e),
button='Ok',
timer=5000)
context = {
'title': 'Add Domain',
'menu_active': 'domains',
'form': form,
'title_submit': 'Save Domain',
'col_size': '4'
}
return render(request, 'maas/form.html', context)
def finish(request, slug):
course = get_object_or_404(Courses, slug=slug)
# cek ketika belom menyelesaikan semua module dan bab.
if course.progress_percentage(request.user, on_thousand=True) != 100:
sweetify.warning(
request,
_(f'Kamu belom menyelesaikan semua materi {course.title}'),
button='OK',
icon='warning',
timer=10000)
return redirect("website:courses:details", course.slug)
enroll = Enrollment.objects.filter(course=course,
user=request.user).first()
enroll.status = Enrollment.STATUS.finish
if not enroll.finishing_date:
enroll.finishing_date = timezone.now().date()
utils.send_notification(
request.user, f'Selamat!',
f'Selamat!, anda berhasil menyelesaikan kelas {enroll.course.title}'
)
enroll.save()
return redirect("website:courses:details", course.slug)
def details(request, slug):
module = get_object_or_404(Module.objects.select_related("course"),
slug=slug)
first_module = module.course.get_first_module()
if not module.id == first_module.id:
# cek apakah module ini sudah pernah dilihat, jika belum maka
# maka cek id module apakah sama dengan next_page_slug, jika tidak sama
# maka munculkan halaman 404
if not check_on_activity(slug=module.slug, type_field='module'):
if module.slug != request.session.get('next_page_slug'):
raise Http404()
pagination = get_pagination(request, module, set_session=True)
prev_type = pagination['prev_type']
prev = pagination['prev']
next_slug = pagination['next']
# handle ketika user belum mengumpulkan tugas pada sesi sebelumnya
# jika page_type adalah section dan section memiliki tugas
if prev_type == 'section' and prev.is_task:
if not request.user.collect_tasks.filter(section=prev):
sweetify.warning(
request,
_(f"Kamu harus mengumpulkan tugas pada sesi {prev.title}"),
button='OK',
icon='warning',
timer=10000)
return redirect("website:sections:details", prev.slug)
# jika next kosong berarti berada pada sesi terakhir
is_complete_tasks = None
course_finish_slug = ""
if not next_slug:
is_complete_tasks = module.course.is_complete_tasks(request.user)
course_finish_slug = module.course.slug
module_all = module.course.modules.publish().prefetch_related(
Prefetch('sections', queryset=Section.objects.publish()))
context = {
'title': module.title,
'module': module,
'pagination': pagination,
'module_all': module_all,
'is_complete_tasks': is_complete_tasks,
"course_finish_slug": course_finish_slug
}
# save activities user to module
if module.has_enrolled(request.user):
module.get_or_create_activity(user=request.user, course=module.course)
module.delete_cache(request.user)
return render(request, 'website/modules/details.html', context)
def checkout(request):
if request.method == "POST":
order_form = OrderForm(request.POST)
payment_form = MakePaymentForm(request.POST)
if order_form.is_valid() and payment_form.is_valid():
order = order_form.save(commit=False)
order.date = timezone.now()
order.save()
cart = request.session.get('cart', {})
total = 0
for id, quantity in cart.items():
product = get_object_or_404(Product, pk=id)
total += quantity * product.price
order_line_item = OrderLineItem(order=order,
product=product,
quantity=quantity)
order_line_item.save()
try:
customer = stripe.Charge.create(
amount=int(total * 100),
currency="GBP",
description=request.user.email,
card=payment_form.cleaned_data['stripe_id'])
except stripe.error.CardError:
sweetify.warning(request, "Your card was declined!")
if customer.paid:
sweetify.success(request, "You have successfully paid")
request.session['cart'] = {}
return redirect(reverse('index'))
else:
sweetify.error(request,
"Unable to take payment",
persistent=':(')
else:
print(payment_form.errors)
sweetify.error(request,
"We were unable to take a payment with that card!",
persistent=':(')
else:
payment_form = MakePaymentForm()
order_form = OrderForm()
return render(
request, "checkout.html", {
"order_form": order_form,
"payment_form": payment_form,
"publishable": settings.STRIPE_PUBLISHABLE
})
def enroll(request, slug):
course = get_object_or_404(Courses, slug=slug)
if course.product and course.product.price > 0:
sweetify.error(
request,
_(f'Kamu harus melakukan pembelian kursus "{course.title}" terlebih dahulu !'
),
button='OK',
icon='error',
timer=10000)
return redirect('website:courses:details', course.slug)
if course.has_enrolled(request.user):
sweetify.success(request,
_(f'Kamu sudah terdaftar di kelas {course.title}'),
button='OK',
icon='success',
timer=10000)
return redirect('website:courses:details', course.slug)
if not course.get_last_batch():
sweetify.warning(
request,
_(f'Kelas {course.title} belum membuka pendaftaran',
button='OK',
icon='warning',
timer=10000))
return redirect('website:courses:details', course.slug)
if course.is_started():
sweetify.warning(
request,
_(f'Gagal mendaftar, kelas {course.title} sudah dimulai'),
button='OK',
icon='warning',
timer=10000)
return redirect('website:courses:details', course.slug)
course.enrolled.create(course=course,
user=request.user,
batch=course.batchs.last())
sweetify.success(request,
_(f'Kamu berhasil mendaftar pada kelas {course.title}'),
button='OK',
icon='success',
timer=10000)
utils.send_notification(
request.user, f'Kamu berhasil mendaftar di kelas {course.title}',
f'Saat ini kamu sudah berhasil mendaftar pada kelas {course.title}. Tunggu info selanjutnya ya.'
)
return redirect('website:courses:details', course.slug)
def updateStatustoPaid(request):
if request.method == "POST":
form = request.POST
sale_entry = form["sale_entry"]
print(sale_entry)
sch_ins = InstallmentSchedule.objects.filter(sale_entry=sale_entry).filter(paid=False).update(paid=True)
sweetify.success(request, _('Successfull Done'), timer=2000)
return redirect(request.META.get('HTTP_REFERER'))
sweetify.warning(request, _('Only Post Method Allowed'), timer=2000)
return redirect(request.META.get('HTTP_REFERER'))
def delete(request, subnet_id):
try:
subnets = maas.get_subnets()
subnet = [s for s in subnets if s['id'] == subnet_id]
if subnet[0] is not None:
m = MAAS()
resp = m.delete(f'subnets/{subnet_id}/')
if resp.status_code in m.ok:
sweetify.success(request, _('Subnet Deleted Successfully'), timer=2000)
return redirect('maas:subnets:index')
sweetify.warning(request, _(resp.text), timer=5000)
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request, 'Warning', text=str(e), icon='error', timer=5000)
return redirect('maas:subnets:index')
def delete(request, space_id):
try:
spaces = maas.get_spaces(space_id)
if not spaces:
sweetify.warning(request, _('Data Space not Found..'), timer=5000)
return redirect('maas.spaces.index')
space_id = spaces[0]['id']
m = MAAS()
resp = m.delete(f'spaces/{space_id}/')
if resp.status_code in m.ok:
sweetify.success(request, _('Spaces Deteled Successfully'), timer=2000)
sweetify.warning(request, _(resp.text), timer=5000)
return redirect('maas:spaces:index')
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request, 'Warning', icon='error', text=str(e), button='Ok', timer=5000)
def register(request):
context = {
'title': 'Register',
}
if request.user.is_authenticated:
return redirect('home-page')
# If registration POST request just sent
if request.method == "POST":
# create a form instance and populate it with data from the request:
form = UserRegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save() # sends the data to the database
current_site = get_current_site(request) # get current site
mail_subject = 'Activate your account.'
message = render_to_string('users/acc_active_email.html', { # create Message
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode("utf-8"),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(
mail_subject, message, from_email=EMAIL_FROM, to=[to_email]
)
try:
email.send()
except:
print("Failed to send email")
sweetify.warning(request, 'Please verify your email address to complete the registration.',
buttons=False,
icon='warning'
)
return redirect('landing-page')
# if a GET (or any other method), create a blank form
else:
form = UserRegistrationForm() # shows the user the registration form (redirection does not occur)
context['form'] = form
return render(request, 'users/register.html', context)
def register_user(request):
if request.method == "POST":
form = RegisterUserForm(request.POST, request.FILES)
print(form)
if User.objects.count() == 0:
if form.is_valid():
form.save()
sweetify.success(request,
"User is successfuly registered",
persistent='Continue',
timer=3000)
return redirect('backend:login')
else:
sweetify.error(request, "Error regestering user")
else:
sweetify.warning(request,
'There is a user already registered',
persistent='Go Away')
return redirect('backend:register')
def add(request):
form = forms.SpacesForm(request.POST or None)
if form.is_valid():
try:
data = form.clean()
m = MAAS()
resp = m.post('spaces/', data=data)
if resp.status_code in m.ok:
sweetify.success(request, _(
'Spaces Successfully Added'), timer=2000)
sweetify.warning(request, _(resp.text), timer=5000)
return redirect('index')
except (MAASError, ConnectionError, TimeoutError) as e:
context = None
sweetify.sweetalert(request, 'Warning', icon='error', text=str(e), button='Ok', timer=5000)
context = {
'title': _('Form Space'),
'form': form,
}
return render(request, 'maas/spaces/add.html', context)
def add(request):
form = VlanForm(request.POST or None)
if form.is_valid():
try:
m = MAAS()
data = form.clean()
fabId = data['fabric_id']
resp = m.post(f'fabrics/{fabId}/vlans/', data=data)
if resp.status_code in m.ok:
sweetify.success(request, _('Vlan Added Successful'), timer=3000)
return redirect('maas:subnets:index')
sweetify.warning(request, _(resp.text), timer=5000)
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request, 'Warning', icon='error', text=str(e), button='Ok', timer=5000)
context = {
'title': _('Add Vlan'),
'form': form
}
return render(request, 'maas/vlans/add.html', context)
def edit(request, vlan_id):
try:
vlan = maas.get_vlans(vlan_id)
form = VlanEditForm(request.POST or None, initial=vlan)
if form.is_valid():
m = MAAS()
data = form.clean()
fabId = data['fabric_id']
vid = data['vid']
resp = m.put(f'fabrics/{fabId}/vlans/{vid}/',data=data)
if resp.status_code in m.ok:
sweetify.success(request, _('Vlan Updated Successful'), timer=3000)
return redirect('maas:subnets:index')
sweetify.warning(request, _(resp.text), timer=5000)
except (MAASError, ConnectionError, TimeoutError) as e:
sweetify.sweetalert(request, 'Warning', icon='error', text=str(e), button='Ok', timer=5000)
context = {
'title': 'Edit Vlan',
'form': form
}
return render(request, 'maas/vlans/add.html', context)
def edit(request, space_id):
try:
spaces = maas.get_spaces(space_id)
form = forms.SpacesForm(request.POST or None, initial=spaces)
if form.is_valid():
data = form.clean()
m = MAAS()
resp = m.put(f'/spaces/{space_id}/', data=data)
if resp.status_code in m.ok:
sweetify.success(request, _(
'Space Successfully Updated'), timer=2000)
sweetify.warning(request, _(resp.text), timer=5000)
return redirect('maas:spaces:index')
except (MAASError, ConnectionError, TimeoutError) as e:
form = None
sweetify.sweetalert(request, 'Warning', icon='error', button='Ok', timer=5000, text=str(e))
context = {
'title': _('Edit Space'),
'form': form
}
return render(request, 'maas/spaces/add.html', context)
def post_update(request, slug):
title = 'Update Post'
post = get_object_or_404(Post, slug=slug)
form = PostForm(request.POST or None, request.FILES or None, instance=post)
author = get_author(request.user)
if request.method == "POST":
if form.is_valid():
form.instance.author = author
form.save()
sweetify.warning(request,
icon='warning',
title='Post Sucessfully Updated',
showCancelButton='true',
confirmButtonColor='#3085d6',
cancelButtonColor='#d33',
confirmButtonText='Yes, delete it!',
showConfirmButton='False',
timer=6000)
# return redirect(reverse("blog:post_detail", kwargs={'id': form.instance.id}))
return redirect(reverse("blog:user_post"))
context = {'title': title, 'form': form}
template = 'blog/post_create.html'
return render(request, template, context)
def signupform(request):
if request.user.is_authenticated:
redirect('/')
if request.method == 'POST':
first_name = request.POST['first_name']
last_name = request.POST['last_name']
username = request.POST['username']
email = request.POST['email']
gender = request.POST['gender']
password1 = request.POST['password1']
password2 = request.POST['password2']
if password1 == password2:
if User.objects.filter(username=username).exists():
sweetify.warning(request, 'Username already taken.')
return render(request, 'signup.html')
elif User.objects.filter(email=email).exists():
sweetify.warning(request, 'Email already exists.')
return render(request, 'signup.html')
else:
user = User.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password1)
userdetails = UserDetails.objects.create(userref=user,
gender=gender)
user.save()
userdetails.save()
sweetify.success(request, 'Registration successful')
else:
sweetify.error(request, 'Email mismatch.')
return render(request, 'signup.html')
return redirect('/')
else:
return render(request, 'signup.html')
def _wrapped_view(request, *args, **kwargs):
quiz_name = kwargs['quiz_name'] if 'quiz_name' in kwargs else kwargs[
'slug']
quiz = get_object_or_404(Quiz.objects.select_related(), url=quiz_name)
# apa bila memiliki jadwal
if quiz.any_schedule():
if timezone.now() < quiz.start_time:
sweetify.warning(request,
_(f"{quiz.title} hasn't started yet"),
button='OK',
icon='warning',
timer=10000)
return redirect('website:index')
elif timezone.now() > quiz.end_time:
finish_out_time(quiz, request.user)
sweetify.warning(request,
_(f"{quiz.title} is over"),
button='OK',
icon='warning',
timer=10000)
return redirect('website:index')
courses = quiz.courses_set.all()
for course in courses:
if course.has_enrolled(request.user):
return view_func(request, *args, **kwargs)
sweetify.warning(
request,
_(f"You are not registered on the quiz <strong> {quiz.title} </strong>"
),
button='OK',
icon='warning',
timer=10000)
return redirect('website:index')
def shopview(request, part='', subpart='', shopid=0):
try:
if request.user.is_authenticated:
if request.method == 'POST':
if 'start' in request.POST:
startshop = Shop.objects.get(pk=shopid)
startshop.shop_state = "START"
startshop.save()
sweetify.success(
request,
startshop.shop_name + ' available to accept orders!')
if 'pause' in request.POST:
pauseshop = Shop.objects.get(pk=shopid)
pauseshop.shop_state = "PAUSE"
pauseshop.save()
sweetify.warning(
request,
pauseshop.shop_name + ' will not accept any orders!')
if 'menudelete' in request.POST:
if Shop.objects.get(pk=shopid).shop_state == 'PAUSE':
if Order.objects.filter(menu=Menu.objects.get(
pk=request.POST['menudelete']),
order_status='ORDERED'):
sweetify.warning(
request,
'Complete the order related to this item before removing it.'
)
else:
remove = Menu.objects.get(
pk=request.POST['menudelete'])
remove.item_state = 'REMOVED'
remove.save()
else:
sweetify.warning(
request,
'Shop have to be in PAUSE state to remove any item.'
)
if 'orderitem' in request.POST:
orderupdate = Order.objects.get(
pk=int(request.POST['orderitem']))
orderupdate.order_status = 'DELIVERED'
orderupdate.deliverydate = timezone.now()
orderupdate.save()
if 'returnshop' in request.POST:
if Order.objects.filter(
menu__item_shop__pk=Shop.objects.get(pk=shopid).pk,
order_status='CART'):
sweetify.error(
request,
'Complete your orders first before you close the shop!'
)
return redirect('/vendor_home/')
shopreturn = Shop.objects.get(pk=shopid)
shopreturn.vendor = None
shopreturn.shop_description = ''
shopreturn.shop_name = 'SHOP' + str(
int(random.random() * 100))
shopreturn.shop_status = 'AVAILABLE'
shopreturn.save()
return redirect('/vendor_home/')
addmenu = AddMenus(
request.POST,
request.FILES,
initial={'item_shop': Shop.objects.get(pk=shopid).pk})
addmenu.fields['item_shop'].disabled = True
if addmenu.is_valid():
addmenu.save()
addfoodcategory = AddFoodCategory(
request.POST,
initial={'shop': Shop.objects.get(pk=shopid).pk})
addfoodcategory.fields['shop'].disabled = True
if addfoodcategory.is_valid():
addfoodcategory.save()
shopdetails = AddShop(request.POST,
request.FILES,
instance=Shop.objects.get(pk=shopid))
if shopdetails.is_valid():
shopdetails.save()
changes = Order.objects.filter(menu__item_shop__pk=shopid)
for item in changes:
item.order_vendor = Shop.objects.get(
pk=shopid).shop_name
item.save()
addmenu = AddMenus(
initial={'item_shop': Shop.objects.get(pk=shopid).pk})
addmenu.fields['item_shop'].disabled = True
shopdetails = AddShop(instance=Shop.objects.get(pk=shopid))
addfoodcategory = AddFoodCategory(
initial={'shop': Shop.objects.get(pk=shopid).pk})
addfoodcategory.fields['shop'].disabled = True
orders = Order.objects.filter(menu__item_shop__pk=Shop.objects.get(
pk=shopid).pk)
orderhistory = OrderHistory.objects.all()
shopobj = Shop.objects.get(pk=shopid)
menus = Menu.objects.filter(item_shop__pk=shopid,
item_state='AVAILABLE')
categorylist = FoodCategory.objects.filter(shop__pk=shopid)
context = {
'shopobj': shopobj,
'menus': menus,
'addmenu': addmenu,
'orders': orders,
'orderhistory': orderhistory,
'categorylist': categorylist,
'addfoodcategory': addfoodcategory,
'shopdetails': shopdetails
}
print(part, subpart)
if part == 'listmenulist' or part == '':
context['listmenulist'] = 'show active'
if part == 'listorderslist':
context['listorderslist'] = 'show active'
if part == 'listcategorylist':
context['listcategorylist'] = 'show active'
if part == 'listshopsettingslist':
context['listshopsettingslist'] = 'show active'
if subpart == 'listviewmenulist' or subpart == '':
context['listviewmenulist'] = 'show active'
if subpart == 'listaddmenulist':
context['listaddmenulist'] = 'show active'
if subpart == 'listvieworderslist':
context['listvieworderslist'] = 'show active'
if subpart == 'listorderhistorylist':
context['listorderhistorylist'] = 'show active'
if subpart == 'listviewcategorylist':
context['listviewcategorylist'] = 'show active'
if subpart == 'listaddcategorylist':
context['listaddcategorylist'] = 'show active'
return render(request, 'shop_view.html', context)
else:
return redirect('/')
except Exception as e:
print(e)
def details(request, slug):
section = get_object_or_404(Section.objects.select_related(
"module", "task_setting", "module__course"),
slug=slug)
file_not_found = None
# cek apakah section ini sudah pernah dilihat, jika belum maka
# maka cek id section apakah sama dengan next_page_slug, jika tidak sama
# maka munculkan halaman 404
if not check_on_activity(slug=section.slug, type_field='section'):
if section.slug != request.session.get('next_page_slug'):
raise Http404()
# dapatkan pagination
pagination = get_pagination(request, section)
prev_type = pagination['prev_type']
prev = pagination['prev']
next_slug = pagination['next']
# handle ketika user belum mengumpulkan tugas pada sesi sebelumnya
# jika page_type adalah section dan section memiliki tugas
if prev_type == 'section' and prev.is_task:
if not request.user.collect_tasks.filter(section=prev):
sweetify.warning(
request,
_(f"Kamu harus mengumpulkan tugas pada sesi {prev.title}"),
button='OK',
icon='warning',
timer=10000)
return redirect("website:sections:details", prev.slug)
# form untuk pengumpulan tugas
collect_task = section.collect_task.filter(user=request.user) \
.select_related("file").first()
# jika ada file
if hasattr(collect_task, 'file'):
# cek apakah objek file bisa mengambil file pada direktorinya
try:
collect_task.file.file.file
file_not_found = False
except (FileNotFoundError, AttributeError):
# jika tidak bisa, kosongkan field file
collect_task.file = None
collect_task.save(update_fields=['file'])
file_not_found = True
form = FormUploadFile(
data=request.POST or None,
files=request.FILES,
section=section,
user=request.user,
instance=None if not collect_task else collect_task.file)
if form.is_valid():
form.save(collect_task=collect_task)
sweetify.success(request,
_(f"Berhasil mengupload tugas"),
button='OK',
icon='success')
return redirect('website:sections:details', slug)
# jika next kosong berarti berada pada sesi terakhir
is_complete_tasks = None
course_finish_slug = ""
if not next_slug:
is_complete_tasks = section.module.course.is_complete_tasks(
request.user)
course_finish_slug = section.module.course.slug
module_all = section.module.course.modules.publish().prefetch_related(
Prefetch('sections', queryset=Section.objects.publish()),
'activities_module')
context = {
'title': section.title,
'section': section,
'pagination': pagination,
'form': form,
'task': collect_task,
'is_complete_tasks': is_complete_tasks,
'file_not_found': file_not_found,
'module_all': module_all,
'course_finish_slug': course_finish_slug
}
# save activities user to section
if section.has_enrolled(request.user):
section.get_or_create_activity(user=request.user,
course=section.module.course)
section.delete_cache(request.user)
return render(request, 'website/sections/details.html', context)
def restuartant_view(request, res=0):
try:
subtotal = 0
if request.method == 'POST':
if request.user.is_authenticated:
usergroup = Group.objects.get(name='customer')
if request.user.groups.filter(name=usergroup).exists():
if 'menu_item_pk' in request.POST:
if Order.objects.filter(customer=request.user, order_status='CART', menu=Menu.objects.get(pk=request.POST['menu_item_pk'])).exists():
cart = Order.objects.get(customer=request.user,order_status='CART', menu=Menu.objects.get(pk=request.POST['menu_item_pk']))
cart.order_quantity = cart.order_quantity + 1
else:
cart = Order()
cart.customer = request.user
cart.menu = Menu.objects.get(pk=request.POST['menu_item_pk'])
cart.order_quantity = 1
cart.order_status = 'CART'
cart.menu_name = Menu.objects.get(pk=request.POST['menu_item_pk']).item_name
cart.menu_image = Menu.objects.get(pk=request.POST['menu_item_pk']).item_image
cart.order_vendor = Menu.objects.get(pk=request.POST['menu_item_pk']).item_shop.shop_name
cart.order_price = Menu.objects.get(pk=request.POST['menu_item_pk']).item_price * cart.order_quantity
cart.save()
sweetify.success(request, cart.menu_name + ' added', timer=1200)
if 'quantity_minus' in request.POST:
try:
cart = Order.objects.get(pk=request.POST['quantity_minus'])
if cart.order_quantity == 1:
cart.delete()
else:
cart.order_quantity = cart.order_quantity - 1
cart.order_price = cart.menu.item_price * cart.order_quantity
cart.save()
except Exception as e:
print(e)
if 'quantity_plus' in request.POST:
try:
cart = Order.objects.get(pk=request.POST['quantity_plus'])
if cart.order_quantity < 10:
cart.order_quantity = cart.order_quantity + 1
cart.order_price = cart.menu.item_price * cart.order_quantity
cart.save()
except Exception as e:
print(e)
else:
sweetify.warning(request, 'must be a customer to add to cart.')
else:
sweetify.error(request, 'must login to the system to add to cart.')
menus = Menu.objects.filter(item_shop=Shop.objects.get(pk=res))
print(res)
category = menus.distinct("item_food_category").all()
shop = Shop.objects.get(pk=res)
context = {'menus': menus, 'shop': shop, 'category': category}
if request.user.is_authenticated:
ordertable = Order.objects.filter(order_status='CART', customer=request.user).order_by('pk')
context['ordertable'] = ordertable
for amt in ordertable:
subtotal = subtotal + amt.order_price
print(subtotal)
context['subtotal'] = subtotal
return render(request, 'restuartant_view.html', context)
except Exception as e:
print(e)
def try_premium(request):
curr_user = UserProfile.objects.get(user=request.user)
try:
# Try to find the client in the Braintree Vault
customer = gateway.customer.find(request.user.username)
print("Found")
except:
# If client not found - create the client and stores in Braintree Vault
customer = gateway.customer.create({
"first_name": f"{request.user.first_name}",
"last_name": f"{request.user.last_name}",
"email": f"{request.user.email}",
"id": f"{request.user.username}"
})
print("New")
try:
# Try to find the payment method of that client
payment_token = gateway.payment_method.find(f"{request.user.username}")
token = payment_token.token
print("Found")
except:
# If not found
# Create a fake payment method for that client
payment_token = gateway.payment_method.create({
"customer_id": customer.customer.id,
"payment_method_nonce": 'fake-valid-nonce', # Fake valid card details
"token": f"{request.user.username}"
})
token = payment_token.payment_method.token
print("New")
if request.user.userprofile.payment_method is False:
sweetify.warning(request, 'Please provide a payment method.',
buttons=False,
icon='warning'
)
return redirect('/settings/?tab=billing&next=/get-premium/')
if not curr_user.premium:
# plus_one_month = datetime.now(timezone.utc) + relativedelta(months=1)
# curr_user.premium_ends = plus_one_month
if not curr_user.trial_used:
# Create the subscription in Braintree
result = gateway.subscription.create({
"payment_method_token": token,
"plan_id": 1234,
})
else:
result = gateway.subscription.create({
"payment_method_token": token,
"plan_id": 1234,
'trial_duration': 0
})
if result.is_success:
print("YES, Subscription activated.")
curr_user.premium = True
curr_user.subscription_id = result.subscription.id
curr_user.save()
if not request.user.userprofile.trial_used:
sweetify.success(request, "Premium account activated!", icon='success',
toast=True,
position='bottom-end',
padding='1.5rem'
)
else:
sweetify.success(request, "Premium account activated! You have successfully paid £9.99!", icon='success',
toast=True,
position='bottom-end',
padding='1.5rem'
)
else:
print(result)
print("No :(")
sweetify.error(request, 'Problem with payment method', icon="error", toast=True, position="bottom-end")
return redirect('/settings/?tab=subscription')
