def new_or_get(self, request):
guest_email_id = request.session.get("guest_email_id")
user = request.user
created = False
obj = None
if user.is_authenticated(
): # Logged in user checkout, guest email no needed anymore
if user.email:
try:
del request.session["guest_email_id"]
except:
pass
obj, created = self.model.objects.get_or_create(
user=user, email=user.email)
elif guest_email_id is not None: # Guest user checkout
guest_email_obj = GuestEmail.objects.get(id=guest_email_id)
obj, created = self.model.objects.get_or_create(
user=None, email=guest_email_obj.email)
else:
loger.info(
f'Could not create BillingProfile, not logged user and no guest email'
)
return obj, created
def recalculate_values(self, new_currency=None):
loger.info(
f'Recalculating cart {self.id} values, currency: {self.currency}, entry total cart value: {self.total}'
)
products = self.products.all().select_for_update()
currency = self.currency
if new_currency:
if new_currency != self.currency:
self.currency = new_currency
currency = new_currency
if products:
total = sum([
product.prices.get_promo(currency) if (product.promo_active)
else product.prices.get_regular(currency)
for product in products
])
else:
total = Money(0.00, currency)
self.total = total
self.save()
loger.info(
f'Recalculated cart {self.id} values, currency: {self.currency}, new total cart value: {self.total}'
)
def send_order_success_mail(request, success_order_id, success_user_email,
success_order_total, bought_products, order_obj):
mail_subject = "naklisze.pl - " + _("Potwierdzenie zamówienia nr ") + str(
success_order_id)
message = render_to_string('carts/checkout_success_email.html', {
'success_order_id':
success_order_id,
'success_user_email':
success_user_email,
'success_order_total':
success_order_total,
'bought_products':
bought_products,
'order':
order_obj,
'settings_url':
request.build_absolute_uri(reverse('accounts:settings')),
'register_url':
request.build_absolute_uri(reverse('accounts:register'))
},
request=request)
return_file_path = os.path.join(settings.STATIC_ROOT,
'formularz_reklamacji.pdf')
regulations_file_path = os.path.join(settings.STATIC_ROOT, 'Regulamin.pdf')
attachments = [return_file_path, regulations_file_path]
recipient_list = [success_user_email, "*****@*****.**"]
send_mail(mail_subject, message, recipient_list, attachments)
loger.info(
f'Success order {success_order_id} email was scheduled to send to {recipient_list}'
)
def form_valid(self, form):
request = self.request
user = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
new_user = User.objects.create_user(user, email, password)
new_user.is_active = False
new_user.save()
loger.info(
f'Created new user account: {new_user.username} with id: {new_user.id}'
)
create_user_msg_text = _("Utworzono konto dla użytkownika ") + str(
user
) + _(
", aktywuj swoje konto postępując zgodnie z instrukcjami wysłanymi na adres e-mail "
) + str(email)
messages.info(request, create_user_msg_text)
# Subscribe to newsletter
newsletter_sub = form.cleaned_data.get('subscribe')
if newsletter_sub:
newsletter_subscribe(request, form, new_user=new_user)
# Send activation mail
send_activation_mail(request, user, email)
next_path = self.get_next_url()
return redirect(next_path)
def get(self, request, *args, **kwargs):
lang = self.kwargs.get('lang')
if lang:
if any(lang in l for l in settings.LANGUAGES):
request.session[LANGUAGE_SESSION_KEY] = lang
loger.info(f'User {request.user} changed language to: {lang}')
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def get(self, request, *args, **kwargs):
currency = self.kwargs.get('currency')
if currency:
if currency in settings.CURRENCIES:
request.session['currency'] = currency
loger.info(
f'Set new currency in ChangeCurrencyView: {currency}')
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def post_save_order_total(sender, instance, created, *args, **kwargs):
if created and not kwargs.get('raw', False):
order_id = instance.id
qs = Order.objects.select_for_update().filter(id=order_id)
if qs.count() == 1:
order_obj = qs.first()
order_obj.update_all()
loger.info(f'Order {order_obj} was changed so it was updated')
def check_if_done(self):
if self.billing_profile and self.shipping_address and self.billing_address and self.total.amount > 0:
loger.info(f'Order {self} is done')
return True
loger.info(f'Order {self} is NOT done,'
f' billing_profile={self.billing_profile},'
f' billing_address={self.billing_address},'
f' shipping_address={self.shipping_address},'
f' total amount={self.total.amount}')
return False
def newsletter_subscribe(request, form, new_user=None, guest_email=None):
if guest_email:
MarketingPref.objects.get_or_create(user=None,
guest_user_email=guest_email)
elif new_user:
MarketingPref.objects.get_or_create(user=new_user)
messages.success(request, _('Zostałeś dodany do naszego Newslettera!'))
loger.info(
f'User {new_user} with email {guest_email} was added to newsletter')
def update_all(self, new_shipping_type=None):
self.update_logged_user_promo()
self.currency = self.cart.currency
shipping_price = self.create_or_update_shipping(
new_shipping_type, self.cart.currency)
self.products_cost = self.cart.total
promotion_factor = Decimal((100 - self.logged_user_promo) / 100)
self.total = self.cart.total * promotion_factor + shipping_price
self.save()
loger.info(f'Updated all stuff in order {self}')
def run(self):
msg = EmailMessage(self.subject, self.message, to=self.recipient_list)
for att in self.attachments:
msg.attach_file(att)
msg.content_subtype = 'html'
msg.send()
loger.info(
f'Email with subject {self.subject} was successfuly send to {self.recipient_list}'
)
def post_save_cart_total(sender, instance, created, *args, **kwargs):
if not created and not kwargs.get('raw', False):
cart_obj = instance
cart_id = cart_obj.id
qs = Order.objects.select_for_update().filter(cart__id=cart_id,
active=True)
if qs.count() == 1:
order_obj = qs.first()
order_obj.update_all()
loger.info(
f'Cart {cart_id} was changed so updated order {order_obj}')
def pre_save_create_order_id(sender, instance, *args, **kwargs):
if not kwargs.get('raw', False):
if not instance.order_id:
instance.order_id = uniqe_order_id_generator(instance)
loger.info(
f'Created new order_id {instance.order_id} for order {instance}'
)
qs = Order.objects.filter(cart=instance.cart).exclude(
billing_profile=instance.billing_profile)
if qs.exists():
qs.update(active=False)
loger.info(f'Stale orders qs was marked as active=false, qs: {qs}')
def process_request(self, request):
current_currency = request.session.get('currency')
if not current_currency:
current_currency = request.session[
'currency'] = settings.DEFAULT_CURRENCY
cart_obj = Cart.objects.get(request)
if cart_obj:
if cart_obj.currency != current_currency:
cart_obj.recalculate_values(new_currency=current_currency)
loger.info(
f'Recalculated cart values with new currency: {current_currency}'
)
def cart_update(request):
product_id = request.POST.get('product')
add_another_multiple = request.POST.get('add_another_multiple')
if product_id is not None:
try:
product_obj = Product.objects.get(id=product_id)
except Product.DoesNotExist:
messages.warning(request,
_('Wystąpił błąd, produkt nie istnieje w bazie'))
loger.error(
f'Product {product_id} was not added to cart because it not exist in DB'
)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
cart_obj, new_obj = Cart.objects.new_or_get(request)
# try add to cart another instance of same type multiple product
if add_another_multiple:
qs = get_another_multiple_product(product_obj, cart_obj)
# if there is available another product -> add to cart
if qs:
new_product = qs[0]
cart_obj.products.add(new_product)
cart_obj.recalculate_values()
else:
loger.warning(
f'Failed to add another multiple product {product_obj} to cart, no more products of this kind'
)
messages.warning(
request,
_('Brak dostępnych kolejnych produktów tego typu'))
else:
if product_obj in cart_obj.products.all():
cart_obj.products.remove(product_obj)
loger.info(
f'Removed product {product_obj} from cart {cart_obj}')
else:
cart_obj.products.add(
product_obj) # cart_obj.products.add(product_id)
loger.info(f'Added product {product_obj} to cart {cart_obj}')
messages.success(request,
_('Produkt został dodany do koszyka'))
request.session['cart_items_count'] = cart_obj.products.count()
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def get_queryset(self, *args, **kwargs):
request = self.request
query = request.GET.get('q')
if query is not None:
SearchQueries.objects.new(request, query)
results = Product.objects.search(query).order_by('-timestamp')
if results is not None:
qs = Product.make_qs_unique(results)
return qs
loger.info(
f'No search results for query {query}, rendering featured products instead'
)
return Product.objects.featured()
def checkout_success(request):
success_order_id = request.session.get('success_order_id')
if not success_order_id:
loger.warning(
f'success_order_id not found in checkout_success view, redirecting to home page'
)
return redirect("home_page")
with transaction.atomic():
order_obj = Order.objects.select_for_update().get(
order_id=success_order_id)
order_obj.update_date()
success_user_email = order_obj.billing_profile.email
success_order_total = order_obj.total
context = {
'success_order_id': success_order_id,
'success_user_email': success_user_email,
'success_order_total': success_order_total
}
bought_products = order_obj.cart.products.all().select_for_update()
for product in bought_products:
product.make_selled()
loger.info(
f'All products in order {order_obj} were marked as bought')
if request.session.get('cart_id'):
del request.session['cart_id']
if request.session.get('cart_items_count'):
del request.session['cart_items_count']
if request.session.get('guest_email_id'):
del request.session['guest_email_id']
# Send order success mail
send_order_success_mail(request, success_order_id, success_user_email,
str(success_order_total), bought_products,
order_obj)
if request.session.get('success_order_id'):
del request.session['success_order_id']
if request.session.get('order_comment'):
del request.session['order_comment']
return render(request, "carts/checkout_success.html", context)
def logout_page(request):
if request.session.get('guest_email_id'):
loger.info(
f'Logged out guest user {request.session.get("guest_email_id")}')
del request.session['guest_email_id']
messages.success(request, _('Zakończono sesję gościa'))
else:
loger.info(f'Logged out user {request.user}')
logout(request)
messages.success(request, _('Pomyślnie wylogowano użytkownika'))
if request.session.get('cart_id'):
del request.session['cart_id']
if request.session.get('cart_items_count'):
del request.session['cart_items_count']
return redirect('/')
def form_valid(self, form):
request = self.request
username = form.cleaned_data.get("username")
password = form.cleaned_data.get("password")
user_auth = authenticate(request, username=username, password=password)
user_obj = User.objects.get(username=username)
if user_obj.is_active == True:
if user_auth is not None:
login(request, user_auth)
messages.success(
request,
_('Pomyślnie zalogowano użytkownika ') + str(username))
loger.info(f'User {str(username)} was logged in')
request.session['username'] = username
if request.session.get('guest_email_id'):
del request.session['guest_email_id']
next_path = self.get_next_url()
return redirect(next_path)
else:
messages.warning(request, _('Niepoprawne hasło!'))
return self.form_invalid(form)
else:
messages.warning(
request,
_('Konto nieaktywne, czy dokonałeś aktywacji? Sprawdź instrukcję wysłaną na adres e-mail:'
) + str(user_obj.email))
loger.info(
f'User tries to log on inactive account {user_obj.username} {user_obj.email}'
)
reactivate_url = f'/accounts/reactivate/{user_obj.username}/{user_obj.email}/'
reactivate_msg_text = _(
"Kliknij w ") + f"<a href='{reactivate_url}'>LINK</a>" + _(
" aby ponownie przesłać link aktywacyjny.")
messages.warning(request, mark_safe(reactivate_msg_text))
return self.form_invalid(form)
def create_or_update_shipping(self, new_shipping_type, currency):
shipping_price_obj = ShippingPrice.objects.first()
if new_shipping_type:
new_shipping_price = getattr(shipping_price_obj,
f'get_{new_shipping_type}')(currency)
self.shipping_price = new_shipping_price
self.shipping_type = new_shipping_type
loger.info(
f'Set new shipping type: {new_shipping_type} with price {new_shipping_price} in order {self}'
)
else:
new_shipping_price = getattr(shipping_price_obj,
f'get_{self.shipping_type}')(currency)
self.shipping_price = new_shipping_price
loger.info(
f'Set new shipping price {new_shipping_price} in order {self}')
return new_shipping_price
def form_valid(self, form):
request = self.request
fullname = form.cleaned_data['fullname']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
subject = "Wiadomość od {}".format(fullname)
try:
send_mail(subject, message, email, ['*****@*****.**'])
messages.success(request, _('Pomyślnie wysłano wiadomość'))
loger.info(
f'Successfuly sent email from {email} using /contacts form')
form = ContactForm(None)
except BadHeaderError:
messages.warning(request,
_('Nastąpił błąd przy wysyłaniu wiadomości'))
loger.exception(f'Error while sending mail from /contacts')
return redirect('about')
def activation_view(request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user_obj = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user_obj = None
if user_obj and account_activation_token.check_token(user_obj, token):
user_obj.is_active = True
user_obj.save()
success_msg_text = _("Aktywowano konto użytkownika ") + str(
user_obj.username) + _(", możesz się już zalogować")
messages.success(request, success_msg_text)
loger.info(f'User {str(user_obj.username)} account was activated')
return redirect('accounts:login')
else:
messages.warning(request, _('Niepoprawny link aktywacji konta!'))
loger.warning(f'Wrong account activation link for User ID {uid}')
return redirect('accounts:register')
def form_valid(self, form):
request = self.request
email = form.cleaned_data.get("email")
new_guest_email = GuestEmail.objects.create(email=email)
request.session['guest_email_id'] = new_guest_email.id
loger.info(
f'New guest user was created: {new_guest_email} with id {new_guest_email.id}'
)
messages.success(
request,
_('Utworzono konto gościa z adresem e-mail ') +
str(new_guest_email))
# Subscribe to newsletter
newsletter_sub = form.cleaned_data.get('subscribe')
if newsletter_sub:
newsletter_subscribe(request,
form,
guest_email=new_guest_email.email)
next_path = self.get_next_url()
return redirect(next_path)
def send_activation_mail(request, user, email):
new_user = User.objects.get(username=user)
mail_subject = _("Aktywuj swoje konto w naklisze.pl")
current_site = get_current_site(request)
message = render_to_string(
'accounts/acc_active_email.html', {
'user': new_user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.pk)),
'token': account_activation_token.make_token(new_user),
})
email_msg = EmailMessage(mail_subject, message, to=[email])
try:
email_msg.send()
loger.info(f'Account activation email was send to {email}')
except:
messages.warning(
request, _('Nastąpił błąd przy wysyłaniu wiadomości aktywacyjnej'))
loger.exception(
f'Error while sending account activation email to {email}')
return redirect("accounts:login")
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(
request) # create or get cart
products = cart_obj.products.all()
order_obj = None
address_qs = None
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get("billing_address_id", None)
shipping_address_id = request.session.get("shipping_address_id", None)
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
if request.session.get('success_order_id'):
del request.session['success_order_id']
if cart_created or cart_obj.products.count(
) == 0: # new empty cart or no products in cart so no checkout
loger.info(
f'cart_created={cart_created} or products_count={cart_obj.products.count()} so redirecting to carts:home '
)
return redirect("carts:home")
if billing_profile is not None: # Billing profile is available so we can create or update order
# make_checkout flag is received via GET trough check_availability
make_checkout = request.GET.get('make_checkout')
del_shipping_address = request.POST.get('del_shipping_address')
del_billing_address = request.POST.get('del_billing_address')
newShippingType = request.POST.get('shippingType')
address_qs = Address.objects.filter(billing_profile=billing_profile,
current=True)
with transaction.atomic():
order_obj, order_obj_created = Order.objects.new_or_get(
cart_obj=cart_obj,
billing_profile=billing_profile,
select_for_update=True)
if shipping_address_id:
order_obj.shipping_address = Address.objects.get(
id=shipping_address_id)
order_obj.save()
del request.session["shipping_address_id"]
loger.info(
f'Added shipping address {shipping_address_id} to order {order_obj}'
)
if billing_address_id:
order_obj.billing_address = Address.objects.get(
id=billing_address_id)
order_obj.save()
del request.session["billing_address_id"]
loger.info(
f'Added billing address {billing_address_id} to order {order_obj}'
)
if newShippingType:
order_obj.update_all(new_shipping_type=newShippingType)
loger.info(
f'Updated order {order_obj} with new shipping type {newShippingType}'
)
if make_checkout:
loger.info(f'Starting checkout for order {order_obj}')
order_is_done = order_obj.check_if_done()
if order_is_done:
order_obj.mark_as_done()
order_obj.add_comment(
request.session.get('order_comment', ''))
request.session['success_order_id'] = order_obj.order_id
loger.info(
f'Order {order_obj} is done, redirecting to carts:checkout_success'
)
return redirect("carts:checkout_success")
# delete current address from order and go back to choose another one
if del_shipping_address or del_billing_address:
if del_shipping_address:
order_obj.shipping_address = None
order_obj.save()
loger.info(
f'Deleted shipping address from order {order_obj}')
elif del_billing_address:
order_obj.billing_address = None
order_obj.save()
loger.info(
f'Deleted billing address from order {order_obj}')
return redirect("carts:checkout")
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form,
"address_form": address_form,
"basket_products": products,
"address_qs": address_qs,
}
return render(request, "carts/checkout.html", context)
def check_availability(request):
next_get_url = request.GET.get('next_url')
next_post_url = request.POST.get('next_url')
make_checkout = request.POST.get('make_checkout')
order_comment = request.POST.get('comment')
redirect_path = (next_post_url or next_get_url) or None
cart_obj, cart_created = Cart.objects.new_or_get(
request, select_for_update=True) # create or get cart
cart_obj.recalculate_values()
products = cart_obj.products.all().select_for_update()
all_available = True
loger.info(f'Checking availability of products in cart {cart_obj}')
for product in products:
if product.selled == True:
loger.info(f'Product {product} is unavailable')
# try replace 'multiple' product with available one
if product.category in product.MULTIPLE_PRODUCTS_CATEGORIES:
loger.info(
f'Product {product} is multiple product, trying to get another available'
)
available_prod_list = get_another_multiple_product(
product, cart_obj)
# if there is available another product -> replace
if available_prod_list:
loger.info(
f'Another multiple products type {product} are available'
)
cart_obj.products.remove(product)
new_product = available_prod_list[0]
cart_obj.products.add(new_product)
loger.info(f'Switched {product} to {new_product}')
continue
# remove not available product from cart
all_available = False
cart_obj.products.remove(product)
request.session['cart_items_count'] = cart_obj.products.count()
deleted_product_msg_text = _("Produkt ") + str(product) + _(
" został usunięty z karty")
messages.warning(request, deleted_product_msg_text)
loger.info(f'Removed unavailable product from cart: {product}')
if all_available is True:
loger.info(f'All products in cart {cart_obj} are available')
if make_checkout:
loger.info(f'Redirecting to checkout view with make_checkout flag')
redirect_path += "?make_checkout=True"
if order_comment:
request.session['order_comment'] = order_comment
return redirect(redirect_path)
else:
messages.warning(
request,
_("Ktoś Cię ubiegł, jeden z wybranych przez Ciebie produktów jest już niedostępny :("
))
loger.info(
f'Some products from cart {cart_obj} were unavailable, redirecting to carts:home '
)
return redirect("carts:home")
def wix_page(request):
context = {}
loger.info(f'Redirecting to wix subdomain')
return render(request, 'wix/wix.html', context)