def edit_profile(request):
# метод для изменения информации о пользователе
# используются две формы, которые отправляются на сервер одной кнопкой
if request.method == 'POST':
profile_form = UserProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
user_form = UserForm(request.POST,
request.FILES,
instance=request.user)
if profile_form.is_valid() and user_form.is_valid():
profile_form.save()
user_form.save()
if info_is_completed(request.user):
messages.success(request, 'Успешное изменение профиля!')
return redirect('/my_profile/')
else:
messages.error(request, 'Необходимо ввести все поля формы')
else:
messages.error(
request, 'Необходимо ввести корректные значения в поля формы!')
else:
profile_form = UserProfileForm(instance=request.user.profile)
user_form = UserForm(instance=request.user)
heading = "Здесь Вы можете изменить личную информацию профиля:"
return render(request, 'data_input.html', {
'profile_form': profile_form,
'user_form': user_form,
'heading': heading
})
def payment_success(request, order_number):
""" Successful checkout payment """
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
# saving user info from mini project
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'phone_number': order.phone_number,
'country': order.country,
'postcode': order.postcode,
'town_or_city': order.town_or_city,
'street_address1': order.street_address1,
'street_address2': order.street_address2,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Payment Success! :)')
if 'shopping_bag' in request.session:
del request.session['shopping_bag']
context = {
'order': order,
}
return render(request, 'checkout/payment_success.html', context)
def checkout_complete(request, order_number):
"""
Handle successful checkouts
"""
order = Order.objects.get(order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
profile_data = {
'default_phone_number': order.phone_number,
'default_email': order.email,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
if 'bag' in request.session:
del request.session['bag']
context = {
'order': order,
}
print(order)
template = 'checkout/checkout_complete.html'
return render(request, template, context)
def user_update(request):
""" User profile settings form """
user = request.user
profile = request.user.get_profile()
if request.method == "POST":
user_form = UserForm(request.POST, instance=user, prefix="UserForm")
profile_form = UserProfileForm(request.POST, request.FILES, instance=profile, prefix="UserProfileForm")
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
request.user.message_set.create(message=_("Your profile settings have been updated."))
return HttpResponseRedirect(profile.get_absolute_url())
else:
user_form = UserForm(instance=user, prefix="UserForm")
profile_form = UserProfileForm(instance=profile, prefix="UserProfileForm")
return render_to_response("profiles/user_update.html", {
"user_form" : user_form,
"profile_form" : profile_form
}, context_instance=RequestContext(request))
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_street_address_1': order.street_address_1,
'default_street_address_2': order.street_address_2,
'default_town_or_city': order.town_or_city,
'default_county': order.county,
'default_postcode': order.postcode,
'default_country': order.country,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
""" Display page once order is successfully submitted """
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_name': order.full_name,
'default_phone_number': order.phone_number,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_city': order.city,
'default_eircode': order.eircode,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, 'Order complete!')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
save_info = request.session.get("save_info")
order = get_object_or_404(Order, order_number=order_number)
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save
messages.success(
request, f"Order successfully processed \
your order number is the following {order_number} \
a confirmation will be sent to {order.email},")
if "cart" in request.session:
del request.session["cart"]
context = {
"order": order,
}
return render(request, "checkout/checkout_success.html", context)
def checkout_success(request, order_number):
"""A view to show the successful user payment"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
# Save the info in the profile if it was checked in the checkout page
if save_info:
profile_data = {
'full_name_profile': order.full_name,
'email_profile': order.email,
'phone_number_profile': order.phone_number,
'country_profile': order.country,
'city_profile': order.city,
'address_profile': order.address,
'postcode_profile': order.postcode,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Successful order: Your order {order_number} will be processed. A confirmation email '
f'will be sent to {order.email}')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attaches user profile to the order
order.user_profile = profile
order.save()
# Saves user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, 'Order successful! \
You will receive a confirmation email shortly.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
messages.success(request, f'Your order has been placed!! \
Your order number is {order_number}. A confirmation \
email will be sent to at {order.email} and we will give you a call \
to arrange cleaning times.')
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_postcode': order.postcode,
'default_county': order.county,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def consultation_success(request, consultation_number):
consultation = get_object_or_404(Consultation,
consultation_number=consultation_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
consultation.user_profile = profile
consultation.save()
profile_info = {
'default_first_name': consultation.first_name,
'default_last_name': consultation.last_name,
'default_phone_number': consultation.phone_number,
'default_email': consultation.email,
}
user_profile_form = UserProfileForm(profile_info, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {consultation_number}.')
template = 'consultation/consultation_success.html'
context = {
'consultation': consultation,
'from_profile': False,
'from_admin': False,
}
return render(request, template, context)
def checkout_success(request, order_number):
Order = get_object_or_404(order, order_number=order_number)
if request.user.is_authenticated:
save_info = request.session.get('save_info')
profile = UserProfile.objects.get(user=request.user)
Order.user_profile = profile
Order.save()
if save_info:
profile_data = {
'default_phone_number': Order.phone_number,
'default_country': Order.country,
'default_postcode': Order.postcode,
'default_town_or_city': Order.town_or_city,
'default_street_address1': Order.street_address1,
'default_street_address2': Order.street_address2,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Order successfully processed! \
Your order number is {order_number}. \
An confirmation will send to {Order.email}')
if 'bag' in request.session:
del request.session['bag']
context = {
'order': Order,
}
template = 'checkout/checkout_success.html'
return render(request, template, context)
def profile_create(request):
"""
GET: show profile creation form
POST: validates and stores data
"""
from profiles.forms import UserProfileForm
if request.method == 'POST':
form = UserProfileForm(request.POST)
if form.is_valid():
user = User()
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.username = form.cleaned_data['email']
user.email = form.cleaned_data['email']
user.set_password(form.cleaned_data['password'])
user.save()
up = UserProfile.objects.get(user=user)
up.country = form.cleaned_data['country']
if form.cleaned_data.has_key('state'):
up.state = form.cleaned_data['state']
if form.cleaned_data.has_key('about'):
up.about = form.cleaned_data['about']
up.save()
return HttpResponseRedirect(reverse('success-profile'))
else:
context = {'formUserProfile': form}
return Render('base.html', RequestContext(request, context))
return HttpResponseRedirect('/#inscriptions')
def add_info(request):
# функция, выводящая форму для ввода информации о пользователе
# или перенаправляющая на страницу профиля при повторной авторизации пользователя
if request.method == 'POST':
profile_form = UserProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
user_form = UserForm(request.POST,
request.FILES,
instance=request.user)
if profile_form.is_valid() and user_form.is_valid():
profile_form.save()
user_form.save()
if info_is_completed(request.user):
messages.success(request, 'Успешное изменение профиля!')
return redirect('/my_profile/')
else:
messages.error(request, 'Необходимо ввести все поля формы')
else:
messages.error(
request, 'Необходимо ввести корректные значения в поля формы!')
elif info_is_completed(request.user):
return redirect('/my_profile/')
else:
profile_form = UserProfileForm(instance=request.user.profile)
user_form = UserForm(instance=request.user)
heading = "Пожалуйста, введите все свои данные в форму ниже:"
return render(request, 'data_input.html', {
'profile_form': profile_form,
'user_form': user_form,
'heading': heading
})
def profile_create(request):
"""
GET: show profile creation form
POST: validates and stores data
"""
from profiles.forms import UserProfileForm
if request.method == 'POST':
form = UserProfileForm(request.POST)
if form.is_valid():
user = User()
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.username = form.cleaned_data['email']
user.email = form.cleaned_data['email']
user.set_password(form.cleaned_data['password'])
user.save()
up = UserProfile.objects.get(user=user)
up.country = form.cleaned_data['country']
if form.cleaned_data.has_key('state'):
up.state = form.cleaned_data['state']
if form.cleaned_data.has_key('about'):
up.about = form.cleaned_data['about']
up.save()
return HttpResponseRedirect(reverse('success-profile'))
else:
context = {'formUserProfile': form}
return Render('base.html',RequestContext(request, context))
return HttpResponseRedirect('/#inscriptions')
def topup_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(OrderCoin, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's coins
coin_data = {
'bookcoins': order.coins + profile.bookcoins,
}
user_coin_form = UserProfileForm(coin_data, instance=profile)
if user_coin_form.is_valid():
user_coin_form.save()
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
'bookcoins': profile.bookcoins,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
if 'current_coin' in request.session:
del request.session['current_coin']
if 'pid' in request.session:
del request.session['pid']
context = {
'order': order,
}
return render(request, 'bookCoins/topup_success.html', context)
def test_update_address_form(self):
login = self.client.login(username="******",
password="******")
user = self.test_user
response = self.client.post(reverse("update_address"))
form_data = {"default_phone_number": "09876", "user": user.id}
form = UserProfileForm(data=form_data)
self.assertTrue(form.is_valid())
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
# check if user wanted to save
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
# only save profile details if user is authenticated
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Once order is complete- update inventory
# convert dictionary string to dictionary
inventory_bag = json.loads(order.original_bag)
# iterate through bag items
for item_id, item_data in inventory_bag.items():
# get product ID, if value is int = no size field
# product = Product.objects.get(id=item_id)
# if item_data is an int, product doesnt have a size
if isinstance(item_data, int):
edit_product_inventory(item_id, item_data)
# if product has size, iterate through each size and
# create line item accordingly
else:
for size, quantity in item_data['items_by_size'].items():
edit_product_inventory(item_id, quantity)
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
# update the user's profile data
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's info
if save_info:
profile_data = {
'full_name': order.full_name,
'phone_number': order.phone_number,
'country': order.country,
'postcode': order.postcode,
'town_or_city': order.town_or_city,
'street_address1': order.street_address1,
'street_address2': order.street_address2,
'county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
# Send the user a confirmation email
cust_email = order.email
subject = render_to_string(
'reservations/confirmation_emails/confirmation_email_subject.txt',
{'order': order})
body = render_to_string(
'reservations/confirmation_emails/confirmation_email_body.txt',
{'order': order, 'contact_email': settings.DEFAULT_FROM_EMAIL})
send_mail(
subject,
body,
settings.DEFAULT_FROM_EMAIL,
[cust_email]
)
if 'oreder' in request.session:
del request.session['order']
template = 'reservations/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
reward = Reward.objects.get(type="Purchase")
# Attach the user's profile to the order
order.user_profile = profile
# Add points earned to order
points_earned = int(math.floor(order.order_total)) * reward.value
order.points_earned = points_earned
# Update profile and order
profile.save()
order.save()
# Save the user's info
if save_info:
profile_data = {
'default_full_name': order.full_name,
'default_email': order.email,
'default_phone_number': order.phone_number,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_town_or_city': order.town_or_city,
'default_county': order.county,
'default_postcode': order.postcode,
'default_country': order.country,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'cart' in request.session:
del request.session['cart']
request.session['discount_applied'] = False
template = 'checkout/checkout_success.html'
context = {
'order': order,
'on_checkout_success_page': True,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
# orderLineItem = get_object_or_404(OrderLineItem, order=order) #
bag = request.session.get('bag', {}) #
current_bag = bag_contents(request) #
discount_percentage = current_bag['discount_percentage'] #
code = current_bag['code'] #
if 'bag' in request.session:
del request.session['bag']
if 'coupon_id' in request.session: #
del request.session['coupon_id'] #
template = 'checkout/checkout_success.html'
context = {
'order': order,
'discount_percentage': discount_percentage, #
'code': code, #
# 'orderLineItem': orderLineItem, #
}
return render(request, template, context)
def checkout_success(request, order_number):
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attaches the users profile to the order
order.user_profile = profile
order.save()
# Save the users info
if save_info:
profile_data = {
'default_full_name': order.full_name,
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order Successful! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
# def _send_confirmation_email(self, order):
# """Sends the user a confirmation email."""
# cust_email = order.email
# subject = render_to_string(
# 'checkout/confirmation_emails/confirmation_email_subject.txt',
# {'order' : order})
# body = render_to_string(
# 'checkout/confirmation_emails/confirmation_email_body.html',
# {'order' : order, 'contact_email' : settings.DEFAULT_FROM_EMAIL})
# send_mail(
# subject,
# body,
# settings.DEFAULT_FROM_EMAIL,
# [cust_email],
# )
return render(request, template, context)
def checkout_success(request, order_number, payment_method):
"""
Handle successful checkouts for
Stripe orders or Oxxo orders
"""
save_info = request.session.get('save_info')
if payment_method == "stripe":
order = get_object_or_404(Order, order_number=order_number)
messages.success(
request, f'Compra confirmada!\
Te hemos mandado la confirmacion a {order.email}.')
else:
order = get_object_or_404(OxxoOrder, order_number=order_number)
messages.success(
request,
f'Te hemos mandado las instrucciones por el pago a {order.email}.'
)
# Attach the user's profile to the order if user is authenticated
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
# save info if user has checked save-info box
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
# save session bag info to a bag variable
bag = request.session['bag']
bag_with_item_name = []
for key, value in bag.items():
product = get_object_or_404(Product, pk=key)
bag_with_item_name.append({'name': product.name, 'quantity': value})
# deletes session bag
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
'bag': bag_with_item_name,
'payment': payment_method
}
return render(request, template, context)
def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(request,
'register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered} )
def checkout_success(request, order_id):
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_id=order_id)
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Create license
cart = request.session.get('cart', {})
for product_id, product_data in cart.items():
try:
product = Product.objects.get(pid=product_id)
if isinstance(product_data, int):
now = datetime.now()
license_item = License(
user=profile,
product=product,
date_acquired=now.strftime("%Y-%m-%d %H:%M"),
)
license_item.save()
except Product.DoesNotExist:
messages.error(
request,
"One of the products in your cart wasn't found. Please contact support to add licenses"
)
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Order ID: {order_id}. A confirmation email will be sent to {order.email}.'
)
if 'cart' in request.session:
del request.session['cart']
context = {
'order': order,
}
return render(request, 'checkout/checkout_success.html', context)
def checkout_success(request, order_reference):
""" view to display order confirmation to user """
show_details = False
order = get_object_or_404(Order, order_reference=order_reference)
order_reference = order.order_reference
save_info = request.session.get('save_info')
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Link the new order to users profile
order.user_profile = profile
order.save()
if save_info == "true":
profile_data = {
'profile_phone_number': order.phone_number,
'profile_country': order.country,
'profile_postcode': order.postcode,
'profile_town_or_city': order.town_or_city,
'profile_street_address1': order.street_address1,
'profile_street_address2': order.street_address2,
'profile_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
if 'cart' in request.session:
del request.session['cart']
# prevent unauthorised users accessing order confirmations
if request.POST:
if request.POST['confirm-email'] == order.email:
# show conf if user confirmed email and order emails match
show_details = True
else:
if 'view_confirmation_authorised' in request.session:
# show conf if user has just completed checkout
# (then delete one-time session var created at checkout/profile)
show_details = True
del request.session['view_confirmation_authorised']
elif request.user.is_authenticated:
# show conf if user and order emails match, or user is superuser
if request.user.email == order.email or request.user.is_superuser:
show_details = True
else:
# will require user to confirm email before showing order conf
show_details = False
order = None
context = {
'order': order,
'show_details': show_details,
'order_reference': order_reference,
}
return render(request, 'cart/checkout_success.html', context)
def test_get_checkout_success_view(self):
session = self.client.session
session['save_info'] = True
session.save()
order_form = OrderForm({
'full_name': 'Adam Lee',
'email': '*****@*****.**',
'phone_number': '0851234567',
'country': 'US',
'postcode': 'here',
'town_or_city': 'herecity',
'street_address1': 'herestreet',
'street_address2': 'herestreet2',
'county': 'herecounty'
})
order = order_form.save()
response = self.client.get('/checkout/checkout_success'
f'/{order.order_number}/')
self.assertEqual(response.status_code, 200)
# Test saving order to user profile if logged in
self.client.force_login(self.testUser)
response = self.client.get('/checkout/checkout_success/'
f'{order.order_number}/')
user_profile = get_object_or_404(UserProfile, user=self.testUser)
user_profile_form = UserProfileForm({
'default_phone_number': '0851234567',
'default_street_address11': 'here',
'default_street_address2': 'here',
'default_town_or_city': 'herecity',
'default_county': 'herecounty',
'default_postcode': 'herepostcode',
'default_country': 'US'
},
instance=user_profile
)
self.assertTrue(user_profile_form.is_valid())
user_profile_form.save()
order = Order.objects.get(user_profile=user_profile)
user_profile = UserProfile.objects.get(user=self.testUser)
self.assertEqual(order.user_profile.default_phone_number,
user_profile.default_phone_number)
# Test if save info is True
order.phone_number = '0861234567'
order.save()
response = self.client.get('/checkout/checkout_success/'
f'{order.order_number}/')
self.assertEqual(order.user_profile.default_phone_number,
user_profile.default_phone_number)
# Check to see if bag is deleted
self.assertFalse(self.client.session.get('bag'))
def checkout_success(request, order_number):
'''
Handles successful checkouts
\n Args:
1. request object
2. order number
\n Returns:
* Renders the checkout success page.
'''
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
split_order_name = order.full_name.split(' ')
# Save the user's info
if save_info:
profile_data = {
'default_first_name': split_order_name[0],
'default_last_name': split_order_name[1],
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
'instagram_handle': profile.instagram_handle,
'linkedin_handle': profile.linkedin_handle,
'facebook_handle': profile.facebook_handle,
'twitter_handle': profile.twitter_handle,
'consultation': profile.consultation,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Order successfully processed!\
Your order number is {order_number}. A confirmation\
email will be sent to {order.email}.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def test_profile_valid_form(self):
form = UserProfileForm(
{
"default_phone_number": "123245",
"default_street_address1": "23 tehioadf",
"default_town_or_city": "hometown",
"default_postcode": "123jdf",
"default_country": "US",
}
)
self.assertTrue(form.is_valid())
def checkout_success(request, order_number):
"""
Handle successful checkouts, random selection from database
for the products promotion modal.
"""
# random product selection from database
# line 155-164 written myself - see README.md for reference
products = Product.objects.all()
try:
random_products_no = random.sample(range(0, len(products)), 12)
except:
random_products_no = random.sample(range(0, len(products)),
len(products))
random_products = []
for r in random_products_no:
random_products.append(products[r])
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'bag' in request.session:
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {'order': order, 'random_products': random_products}
return render(request, template, context)
def checkout_success(request, order_number):
"""
This code was highly inspired from Code Institute: Boutique Ado.
It handles sucessful checkouts and renders the checkout success
page.
Input:
request (object): The HttpRequest object
order_number (str): The order number of current order.
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
order.save()
# Save the user's info
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {order_number}. You can look at your order\
history in My Profile-page. And from that page you can always\
come back to this page and look at the order.')
if 'cart' in request.session:
del request.session['cart']
if 'cart_rental' in request.session:
del request.session['cart_rental']
if 'months' in request.session:
del request.session['months']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def test_address_form_not_required(self):
valid_data = {
'default_phone_number': '',
'default_postcode': '',
'default_town_or_city': '',
'default_street_address1': '',
'default_street_address2': '',
'default_county': '',
}
form = UserProfileForm(data=valid_data)
self.assertTrue(form.is_valid())
self.assertFalse(form.errors)
def profile_save(request, user_id):
user = User.objects.get(id=user_id)
if request.user != user:
raise Http404
if request.POST:
form = UserProfileForm(request.POST, instance=user.profile)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('profiles.views.profile', kwargs={'user_id': user.id}))
else:
form = UserProfileForm(instance=user.profile)
return render_to_response(request, 'profiles/profile_save.html', {
'form': form,
})
def register(request, key=''):
registered = False
try:
invite_record = Invitation.objects.get(key=key)
if invite_record.activated == True:
return HttpResponseRedirect(reverse('home'))
except ObjectDoesNotExist:
return HttpResponseRedirect(reverse('home'))
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.save()
profile = profile_form.save(commit=False)
invite_record = Invitation.objects.get(key=key)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
invite_record.activated = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm(instance=invite_record)
profile_form = UserProfileForm()
return render(request,
'register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register(request):
result = False
full_form = UserProfileForm(request.POST or None)
simple_form = RegistrationFormUniqueEmail(request.POST or None)
if simple_form.is_valid():
email = simple_form.cleaned_data['email']
password = simple_form.cleaned_data['password']
user, __ = User.objects.get_or_create(username=email, email=email)
user.set_password(password)
user.save()
msg = u'<p>Благодарим вас за регистрацию на нашем ивенте. Мы будем оповещать вас о важных событиях.</p><p>Вы уже можете <a href="http://hackpoint.ru/login/">войти на сайт</a> и найти себе команду.</p><p>С уважением организаторы.</p>'
send_html_mail(u'Спасибо за регистрацию на hackpoint.ru', '', msg, settings.DEFAULT_FROM_EMAIL, [user.email])
result = True
new_user = authenticate(username=email,
password=password)
login(request, new_user)
#return HttpResponseRedirect("/dashboard/")
if full_form.is_valid():
profile = full_form.save(commit=False)
email = request.POST.get('email', None)
username = request.POST.get('username', None)
if email:
user, created = User.objects.get_or_create(username=email, email=email)
user.profile.username = username
user.profile.user_skills = profile.user_skills
user.profile.user_role = profile.user_role
user.profile.has_idea = profile.has_idea
user.profile.contact = profile.contact
user.save()
user.profile.save()
result = True
if result:
return {
'created': result,
'url': resolve_url('profile_detail', pk=user.id)
}
return redirect('/')
def register(request):
# If it's a HTTP POST, we're interest in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information
# Note that we make use of both UserCreationForm and UserProfileForm.
user_form = UserCreateForm(request.POST)
profile_form = UserProfileForm(request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# AutoLogin the user after registration
autologin(user_form, request)
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Now we save the UserProfile model instance
profile.save()
# Redirect the user to home
return HttpResponseRedirect("/")
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal
# They'll also be shown to the user
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances
# These forms will be blank, ready for user input
else:
user_form = UserCreateForm()
profile_form = UserProfileForm()
# Render the template depending on the context
return render(request, "registration/register.html", {'user_form': user_form, 'profile_form': profile_form})
def update_profile(request):
submitted = False
inst = UserProfile.objects.get(user=request.user)
if request.method == 'POST':
profile_form = UserProfileForm(data=request.POST, instance=inst)
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user= request.user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
submitted=True
else:
print profile_form.errors
else:
profile_form = UserProfileForm(instance=inst)
return render(request, 'update_profile.html', {'profile_form': profile_form, 'submitted': submitted})
