def post(self, *args, **kwargs):
username = self.request.POST.get('username')
password = self.request.POST.get('password')
if not username or not password:
messages.error(self.request, 'Usuário ou senha inválidos.')
return redirect('perfil:criar')
autenticacao = authenticate(self.request,
username=username,
password=password)
if not autenticacao:
messages.error(
self.request,
'Usuário não existe. Gentileza realizar o cadastro.')
return redirect('perfil:criar')
login(self.request, user=autenticacao)
messages.success(
self.request,
f'Login efetuado com sucesso. Olá, {self.request.user.first_name}!'
)
if not self.request.session.get('cart'):
return redirect('produto:lista')
return redirect('produto:cart')
def form_valid(self, form):
#Saving Custom User Object for Merchant User
user = form.save(commit=False)
user.is_active = True
user.user_type = 3
user.set_password(form.cleaned_data["password"])
user.save()
#Saving Merchant user
profile_pic = self.request.FILES["profile_pic"]
fs = FileSystemStorage()
filename = fs.save(profile_pic.name, profile_pic)
profile_pic_url = fs.url(filename)
user.merchantuser.profile_pic = profile_pic_url
user.merchantuser.company_name = self.request.POST.get("company_name")
user.merchantuser.gst_details = self.request.POST.get("gst_details")
user.merchantuser.address = self.request.POST.get("address")
is_added_by_admin = False
if self.request.POST.get("is_added_by_admin") == "on":
is_added_by_admin = True
user.merchantuser.is_added_by_admin = is_added_by_admin
user.save()
messages.success(self.request, "Merchant User Created")
return HttpResponseRedirect(reverse("merchant_list"))
def admin_profile_save(request):
if request.method == "POST":
first_name = request.POST.get("first_name")
last_name = request.POST.get("last_name")
# profile_pic = request.FILES.get("profile_pic")
try:
customuser = CustomUser.objects.get(id=request.user.id)
customuser.first_name = first_name
customuser.last_name = last_name
# if password!=None and password!="":
# customuser.set_password(password)
customuser.save()
admin_user = AdminUser.objects.get(auth_user_id=request.user.id)
fs = FileSystemStorage()
filename = fs.save(profile_pic.name, profile_pic)
profile_pic_url = fs.url(filename)
admin_user.profile_pic = profile_pic_url
admin_user.save()
messages.success(request, "Successfully Updated Profile")
return HttpResponseRedirect(reverse("admin_profile"))
except:
messages.error(request, "Failed to Update Profile")
return HttpResponseRedirect(reverse("admin_profile"))
return HttpResponseRedirect(reverse("admin_profile"))
def post(self, request, *args, **kwargs):
try:
Tag(name=self.request.POST['name']).save()
messages.success(self.request, "Tag added successfully")
return redirect('blog:tag-list')
except:
raise ValueError("Slug Field already exists")
def post(self, request):
rform = RegistrationForm(request.POST)
if rform.is_valid():
rform.save()
messages.success(request, "Register Success Full Now Login !")
return redirect("registration:login")
return render(request, 'registration/registration.html',
{'form': rform})
def form_valid(self, form):
msg = "Your account activation link sent. Please check your email."
messages.success(self.request, msg)
email = form.cleaned_data.get("email")
obj = EmailActivation.objects.email_exists(email).first()
user = obj.user
new_activation = EmailActivation.objects.create(user=user, email=email)
new_activation.send_activation()
return super(AccountEmailActivateView, self).form_valid(form)
def post(self, request):
form = OrderCreateForms(request.POST)
user = request.user
cart = Cart(request)
today = timezone.now().date()
if form.is_valid():
promo_code = form.cleaned_data['promo_code']
discount_amount = 0
if promo_code:
try:
promo = Promo.objects.get(code__icontains=promo_code, is_active=True,
start_date__gte=today, end_date__lte=today)
except:
messages.warning(request, "Wrong or Invalid Promo Code")
return redirect('cart-submit-url')
if promo:
print(promo)
if promo.max_uses_limit >= promo.use_count:
promo_user = UserPromoCode.objects.filter(promo_code=promo, user=user)
if not promo_user:
if cart.get_total_price() > promo.min_amount:
discount_amount = promo.value
UserPromoCode.objects.create(promo_code=promo, user=user,
discounted_amount=discount_amount)
promo.use_count += 1
promo.save()
else:
promo_code = ""
messages.warning(request, "Your Cart Price Is Low")
return redirect('cart-submit-url')
else:
promo_code = ""
messages.warning(request, "You have already Use is Promo code")
return redirect('cart-submit-url')
else:
promo_code = ""
messages.warning(request, "This Promo code is Already reach his limit")
return redirect('cart-submit-url')
address = Address.objects.create(user=user, full_name=form.cleaned_data['full_name'],
phone=form.cleaned_data['phone'],
address_line_1=form.cleaned_data['address_line_1'],
city=form.cleaned_data['city'], country=form.cleaned_data['country'],
postal_code=form.cleaned_data['postal_code'])
order_obj = Order.objects.create(customer=user, shipping_address=address,
shipping_method=form.cleaned_data['shipping_method'],
discount_amount=discount_amount, promo_code=promo_code
)
if order_obj:
for item in cart:
Item.objects.create(order=order_obj, product=item['product'], price=item['price'],
quantity=item['quantity'])
cart.clear()
messages.success(request, "Your Order is placed")
return redirect('/')
def register_view(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,
'Your Account has been created successfully.')
return redirect('shop:login')
form = UserCreationForm()
context = {'form': form}
return render(request, 'shop/register.html', context=context)
def profile(request):
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
if u_form.is_valid():
u_form.save()
messages.success(request, f'Your Account has been Updated!')
return redirect('profile1')
else:
u_form = UserUpdateForm(instance=request.user)
context = {'u_form': u_form}
return render(request, 'accounts/profile1.html', context)
def register_page(request):
form = RegisterForm(request.POST or None)
template_name = 'accounts/register.html'
context = {
"form": form
}
if form.is_valid():
full_name = form.cleaned_data.get("full_name")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
new_user = User.objects.create_user(email, full_name, password)
messages.success(request, "Your are registered!")
return redirect('login-url')
return render(request, template_name, context)
def single_order(request, id):
if request.user.is_staff:
object = Order.objects.get(id=id)
cart_obj = OrderItem.objects.filter(order=object)
form = OrderStatusForm(request.POST or None,
request.FILES or None,
instance=object)
if form.is_valid():
instance = form.save()
instance.save()
messages.success(request, 'Order Update Successfully')
context = {'obj': object, 'form': form, 'cart_obj': cart_obj}
return render(request, 'control_panel/single_order.html', context)
return redirect('dashboard_home')
def activate(request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = CustomUser.objects.get(pk=uid)
except(TypeError, ValueError, OverflowError, CustomUser.DoesNotExist):
user = None
if user is not None and account_activation_token.check_token(user, token):
user.is_active = True
user.save()
login(request, user)
messages.success(request, message='Successful activation!')
signals.user_activated.send(sender='activated_user', msg=f"Account for {user.email} has been activated!")
return HttpResponseRedirect(reverse('index'))
else:
return HttpResponse('Activation link is invalid!')
def form_valid(self,form):
#Saving Custom User Object for Merchant User
user=form.save(commit=False)
user.save()
#Saving Merchant user
customeruser=CustomerUser.objects.get(auth_user_id=user.id)
if self.request.FILES.get("profile_pic",False):
profile_pic=self.request.FILES["profile_pic"]
fs=FileSystemStorage()
filename=fs.save(profile_pic.name,profile_pic)
profile_pic_url=fs.url(filename)
customeruser.profile_pic=profile_pic_url
customeruser.save()
messages.success(self.request,"Customer User Updated")
return HttpResponseRedirect(reverse("customer_list"))
def contact_page(request):
contact_form = ContactForm(request.POST or None)
template_name = 'contact/contact.html'
context = {"form": contact_form}
if request.method == 'POST':
name = request.POST.get('name')
email = request.POST.get('email')
phone = request.POST.get('phone')
subject = request.POST.get('subject')
message = request.POST.get('message')
Contact.objects.create(name=name,
phone=phone,
email=email,
subject=subject,
message=message)
messages.success(request, "Your Message send successful")
return render(request, template_name, context)
def account_info(request):
user = request.user
billing_obj = get_object_or_404(BillingProfile, user=user, active=True)
if billing_obj:
form = BillingProfileForm(request.POST or None,
request.FILES or None,
instance=billing_obj)
else:
form = BillingProfileForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = user
instance.save()
messages.success(request, 'Billing Profile Update Successfully')
return redirect('dashboard_home')
return render(request, 'dashboard/account_info.html', {
'form': form,
'object': billing_obj
})
def form_valid(self,form):
#Saving Custom User Object for Merchant User
user=form.save(commit=False)
user.is_active=True
user.user_type=4
user.set_password(form.cleaned_data["password"])
user.save()
#Saving Merchant user
profile_pic=self.request.FILES["profile_pic"]
fs=FileSystemStorage()
filename=fs.save(profile_pic.name,profile_pic)
profile_pic_url=fs.url(filename)
user.customeruser.profile_pic=profile_pic_url
user.save()
messages.success(self.request,"Customer User Created")
return HttpResponseRedirect(reverse("customer_list"))
def post(self, *args, **kwargs):
token = self.request.POST.get('stripeToken')
user_basket_qs = self.request.user.basket.basketproduct_set.all()
total = 0
for product in user_basket_qs:
total += product.product.price * product.quantity
try:
stripe.Charge.create(
amount=int(total * 100), # pence
currency='gbp',
source=token,
description=f'Charge for {self.request.user.username}')
for product in user_basket_qs:
product.delete()
messages.success(self.request, 'Thank you for your purchase.')
return redirect('shop:home')
except stripe.error.CardError as e:
messages.warning(self.request, f"{e.error.message}")
except stripe.error.RateLimitError as e:
messages.warning(self.request, "Rate limit error")
except stripe.error.InvalidRequestError as e:
messages.warning(self.request, "Invalid parameters")
except stripe.error.AuthenticationError as e:
messages.warning(self.request, "Not authenticated")
except stripe.error.APIConnectionError as e:
messages.warning(self.request, "Network error")
except stripe.error.StripeError as e:
messages.warning(
self.request,
"Something went wrong, you were not charged please try again")
except Exception as e:
messages.warning(self.request,
"Serious error occurred, we have been notified")
def create_order(request, id):
form = CreateOrder(request.POST or None)
user_form = LoginForm()
service = get_object_or_404(Service, id=id)
print(service)
if form.is_valid():
obj = Order()
obj.short_note = form.cleaned_data.get("short_note")
obj.address_line_1 = form.cleaned_data.get("address_line_1")
obj.city = form.cleaned_data.get("city")
obj.postal_code = form.cleaned_data.get("postal_code")
obj.service = service
obj.customer = request.user
obj.save()
messages.success(request, "Your Hire Order Create Successfully!")
return redirect('index')
return render(request, 'service/order.html', {
'login_form': user_form,
'form': form
})
def form_valid(self, form):
user = form.save(commit=False)
user.is_active = True
user.user_type = 3
user.set_password(form.cleaned_data['password'])
user.save()
# Saving user.partnerusers
partneruser = PartnerUser.objects.get(auth_user_id=user.id)
if self.request.FILES.get('profile_pic', False):
partneruser.profile_pic = self.request.FILES['profile_pic']
partneruser.date_of_birth = date(
*map(int,
self.request.POST.get('date_of_birth').split('-')))
partneruser.phone_number = self.request.POST.get('phone_number')
partneruser.address_line_1 = self.request.POST.get('address_line_1')
partneruser.address_line_2 = self.request.POST.get('address_line_2')
partneruser.address_town = self.request.POST.get('address_town')
partneruser.address_region = self.request.POST.get('address_region')
partneruser.address_country = self.request.POST.get('address_country')
partneruser.address_zip_code = self.request.POST.get(
'address_zip_code')
is_added_by_admin = False
if self.request.POST.get('is_added_by_admin') == 'on':
is_added_by_admin = True
partneruser.is_added_by_admin = is_added_by_admin
partneruser.save()
messages.success(self.request, 'Partner user updated')
return HttpResponseRedirect(reverse('crm:admin_partner_list_view'))
def form_valid(self, form):
""" Begin reCAPTCHA validation """
recaptcha_response = self.request.POST.get('g-recaptcha-response')
url = 'https://www.google.com/recaptcha/api/siteverify'
values = {
'secret': os.environ.get('CAPTCHA_SECRET'),
'response': recaptcha_response
}
data = urllib.parse.urlencode(values).encode()
req = urllib.request.Request(url, data=data)
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode())
""" End reCAPTCHA validation """
if result['success']:
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(self.request)
mail_subject = f'Activate your account at {current_site.name}.'
message = render_to_string('blog/acc_activate_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(
mail_subject, message, to=[to_email]
)
email.send()
messages.success(self.request, message='Please confirm your email address to complete the registration!')
# user = authenticate(email=form.cleaned_data['email'], password=form.cleaned_data['password1'], )
# login(self.request, user, backend='django.contrib.auth.backends.ModelBackend')
return HttpResponseRedirect(reverse('login'))
else:
messages.error(self.request, 'Invalid reCAPTCHA. Please try again.')
return HttpResponseRedirect(reverse('signup'))
def get(self, request, key=None, *args, **kwargs):
if key is not None:
qs = EmailActivation.objects.filter(key__iexact=key)
confirm_qs = qs.conformable()
if confirm_qs.count() == 1:
obj = confirm_qs.first()
obj.activate()
messages.success(
self.request,
"Your email has been confirmed. You can login now.")
return redirect('login')
else:
activated_qs = qs.filter(key__iexact=key, activated=True)
if activated_qs.exists():
reset_link = reverse('password_reset')
msg = """Your email has already confirmed!
Did you mean <a href="{link}">reset your password</a>?
""".format(link=reset_link)
messages.info(self.request, mark_safe(msg))
return redirect('login')
context = {'form': self.get_form(), 'key': self.key}
return render(self.request, 'registration/activation_error.html',
context)
def delete(self, request, *args, **kwargs):
messages.success(request, self.success_message)
return super(RemoveExpenseFolderUsers, self).delete(request, *args, **kwargs)
def form_valid(self, form):
form.instance.createdBy = self.request.user
messages.success(self.request, f'Store info has been updated') # Awaiting admin approval for publishing
return super().form_valid(form)
def form_valid(self, form):
messages.success(self.request, f'Business has been created') # Awaiting admin approval for publishing
return super().form_valid(form)
def get(self, request, *args, **kwargs):
messages.success(request, '{} {}'.format(_('Welcome'),
request.user.first_name))
return super(AccountsPanel, self).get(request, *args, **kwargs)
def post(self, *args, **kwargs):
http_referer = self.request.META.get('HTTP_REFERER',
reverse('produto:lista'))
if not self.userform.is_valid() or not self.perfilform.is_valid():
messages.error(
self.request,
'Existem erros no formulário de cadastro. Verifique se os campos foram preenchidos corretamente.'
)
return self.renderizar
username = self.userform.cleaned_data.get('username')
password = self.userform.cleaned_data.get('password')
email = self.userform.cleaned_data.get('email')
first_name = self.userform.cleaned_data.get('first_name')
last_name = self.userform.cleaned_data.get('last_name')
# Usuário logado: atualização
if self.request.user.is_authenticated:
usuario = get_object_or_404(User,
username=self.request.user.username)
usuario.username = username
if password:
usuario.set_password(password)
usuario.email = email
usuario.first_name = first_name
usuario.last_name = last_name
usuario.save()
messages.success(self.request, 'Usuário atualizado com sucesso.')
if not self.perfil:
self.perfilform.cleaned_data['usuario'] = usuario
print(self.perfilform.cleaned_data)
perfil = models.Perfil(**self.perfilform.cleaned_data)
perfil.save()
else:
perfil = self.perfilform.save(commit=False)
perfil.usuario = usuario
perfil.save()
# Usuário não logado (novo):
else:
usuario = self.userform.save(commit=False)
usuario.set_password(password)
usuario.save()
perfil = self.perfilform.save(commit=False)
perfil.usuario = usuario
perfil.save()
messages.success(self.request,
f'O usuário {usuario} foi criado com sucesso.')
if password:
autenticacao = authenticate(
self.request,
username=usuario,
password=password,
)
if autenticacao:
login(self.request, user=usuario)
self.request.session['cart'] = self.carrinho
self.request.session.save()
if not self.request.session.get('cart'):
return redirect('produto:lista')
return redirect('produto:cart')
def post(self,request):
form=RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,"You Are Register Successfully Now Login !")
return render(request,'signup.html',{'form':form})
