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 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 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 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 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}.')
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):
# This will confirm a successful order
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
# Add user profile to each order
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
order.user_profile = profile
order.save()
# Save profile information
if save_info:
profile_data = {
'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_post_code': order.post_code,
'default_county': order.county,
'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'Your order({order_number[:6]}) was a success. A\
confirmation email will be sent to your address.')
if 'bag' in request.session:
bag = request.session.get('bag', {})
for item_id, quantity in bag.items():
try:
pack = Pack.objects.get(id=item_id)
pack.sales += 1
pack.save()
except Pack.DoesNotExist:
print("Didn't work")
del request.session['bag']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""
Handles successful checkouts and saves user's
address to their profile, if selected. Created following
CI video lessons.
"""
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 booking
order.user_profile = profile
order.save()
# Saves the user's information to their profile
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, 'Success! Your reservation has been made.')
if 'retreat' in request.session:
del request.session['retreat']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
"""Succesful checkouts"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
"""PUT DELETE ITEM FROM DATABASE HERE?"""
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'Ohh yeah! Thank you! \
I will send a confirmation email to: \
{order.email}.')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
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 get_context_data(self, *args, **kwargs):
context = super(UserProfileDetailView,
self).get_context_data(*args, **kwargs)
context['form'] = UserProfileForm(initial={
'user':
self.request.user,
'phone_no':
self.request.user.phone_no
},
instance=self.get_object())
context['fundraisers'] = self.request.user.campaign_admin.all()
return 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_city': order.city,
'default_streetaddress': order.streetaddress,
'default_house_number': order.house_number,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Your order has been placed! \
Thanks for shopping at Poster Bay!')
# once order is placed delete session
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()
if save_info:
profile_data = {
'default_phone_number': 'Phone Number',
'default_postcode': 'Postal Code',
'default_city': 'City',
'default_street_address1': 'Street Address 1',
'default_street_address2': 'Street Address 2',
'default_county_or_state': 'County, State or Locality',
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order placed successfully. \
Your order number is {order_number}. You will receive a \
confirmation mail to {order.email}. The product will \
also be sent 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):
"""
Check out successfully
"""
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)
# Link order with profile
order.user_profile = profile
order.save()
# Save user information
if save_info:
profile_data = {
'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_country': order.country,
'default_postcode': order.postcode,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(request, f'Your order has been placed! \
Your order number is {order_number}.')
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)
# 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_email': order.email,
'default_country': order.country,
'default_postcode': order.postcode,
'default_city': order.city,
'default_address': order.address,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'We have processed your order. \
Your order number is {order_number}. \
You will receive a confirmation to your registered email, \
{order.email}, within the next minutes.')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
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 checkout_success(request, order_number):
""" Takes the newly made order from checkout and renders
it out for the user who just successfully purchased a product.
It's also linked to their profile here, if they have one.
The bag is now deletes """
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_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} and 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):
""" View that will be rendered when the client successfully filled and submitted the form"""
save_info = request.session.get('save_info') # Check to see if user selected the save form information option
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 available
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'Your order has been successfully processed! \
Your order number is {order_number}. A confirmation \
email has been sent to {order.email}.')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def payment_success(request, order_number):
""" View to handle successful purchases """
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_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! \
A confirmation email will be sent to {order.email}.')
if 'cart' in request.session:
del request.session['cart']
template = 'payment/payment_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, receipt_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
receipt = get_object_or_404(Receipt, receipt_number=receipt_number)
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
receipt.user_profile = profile
receipt.save()
if save_info:
profile_data = {
'default_phone_number': receipt.phone_number,
'default_country': receipt.country,
'default_postcode': receipt.postcode,
'default_town_or_city': receipt.town_or_city,
'default_street_address': receipt.street_address,
}
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 receipt number is {receipt_number}. A confirmation \
email will be sent to your email at: {receipt.email}.')
if 'basket' in request.session:
del request.session['basket']
template = 'checkout/checkout_success.html'
context = {
'receipt': receipt,
}
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)
profile = UserProfile.objects.get(user=request.user)
profile.membership = order.membership
profile.save()
# Attach the users profile to the order
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_full_name': order.full_name,
'default_email': order.email,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_town_or_city': order.town_or_city,
'default_postcode': order.postcode,
'default_country': order.country,
'membership': order.membership,
}
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 has been sent to {order.email}.')
if 'basket' in request.session:
del request.session['basket']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
""" View to display the checkout success template """
template = 'checkout/checkout_success.html'
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
""" If the user in authenticated, save default delivery
information to the user's profile """
if request.user.is_authenticated:
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()
""" Final message to the user that their order was successful """
messages.success(
request, f'Order processed successfully!\
Your order number is {order_number}.\
A confirmation email will be sent to {order.email}')
if 'cart' in request.session:
del request.session['cart']
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)
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
if order.promo_code == '':
generate_promo_code(order.user_profile, order.grand_total)
order.save()
# Save the user's info
if save_info:
profile_data = {
'full_name': order.full_name,
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_city': order.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 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
'PROMO_CODE_VALUE': PROMO_CODE_VALUE,
}
return render(request, template, context)
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 checkout_success(request, order_number):
""" Handles payments that is successfully made """
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_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! \
A confirmation mail with your ordernumber {order_number} \
will be sent to {order.email}. Thanks for buying from Old And Gold.'
)
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):
"""
Success page for 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)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_address_line1': order.address_line1,
'default_address_line2': order.address_line2,
'default_city': order.city,
'default_postcode': order.postcode,
'default_country': order.country,
'default_phone_number': order.phone_number,
}
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}. Confirmation \
will be sent to {order.email}.')
# remove the users cart items from the session
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):
""" A view to handle successfull 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)
order.user_profile = profile
order.save()
if save_info:
profile_data = {
'default_full_name': order.full_name,
'default_email': order.email,
'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: {order_number} \
Your order was successfully processed.')
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):
"""
Successful checkout handler
"""
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 user profile to order
order.user_profile = profile
order.save()
# Save user contact & delivery details checkbox
if save_info:
profile_data = {
'default_phone_number': order.phone_number,
'default_street_address': order.street_address,
'default_post_code': order.post_code,
'default_town_or_city': order.town_or_city,
'default_county': order.county,
'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 confirmed! \
Your order number is {order_number}. We have sent \
a confirmation email 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):
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
profile = UserPage.objects.get(user=request.user)
order.user_page = profile
order.save()
user_page_form = UserProfileForm(instance=profile)
if user_page_form.is_valid():
user_page_form.save()
messages.success(
request,
f'Yipee! Order accepted!, Your order number is {order_number}')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def complete(request):
"""
Page sent to on successful subscription creation/payment. Also updates user
information if save_shipping variable is true.
"""
profile = get_object_or_404(UserProfile, user=request.user)
save_shipping = request.session["save_shipping"]
# Checks the state of save_shipping in the session.
# If equals True, updates userprofile delivery address.
if save_shipping:
shipping_data = request.session["shippingdata"]
update_form = UserProfileForm(shipping_data, instance=profile)
if update_form.is_valid():
update_form.save()
messages.success(request, "Delivery information updated!")
# Remove shippingdata for safety reasons, found on
# https://docs.djangoproject.com/en/3.2/topics/http/sessions/
del request.session["shippingdata"]
template = "subscriptions/complete.html"
return render(request, template)
def checkout_success(request, order_number):
"""
Handle successful checkouts
"""
order = get_object_or_404(Order, order_number=order_number)
booking = order.date_booked
if request.user.is_authenticated:
profile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = profile
booking.user_profile = profile
order.save()
booking.save()
profile_data = {
'full_name': order.full_name,
'default_phone_number': order.phone_number,
}
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_confirmation_email(order, booking)
subject = 'A new booking has been made'
from_email = '*****@*****.**'
message = 'A new booking has been made on The James Master'
send_mail(subject, message, from_email, ['*****@*****.**'])
template = 'booking/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def checkout_success(request, order_number):
""" Success Checkout Handler """
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_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 { order_number } Successed!\
# We will send you the confirmation detail 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 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})
def checkout_success(request, order_number):
"""
Handle successful checkout
"""
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_full_name': order.full_name,
'default_email': order.email,
'default_phone_number': order.phone_number,
}
user_profile_form = UserProfileForm(profile_data, instance=profile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully proceessed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'cart' in request.session:
del request.session['cart']
template = 'checkout/checkout_success.html'
context = {
'order': order,
}
return render(request, template, context)
def test_checkout_view_autofill_if_logged_in_with_info_saved(self):
# Check if user is authenticated, autofil form
session = self.client.session
session['bag'] = self.bag_with_item
session.save()
self.client.force_login(self.testUser)
response = self.client.get('/checkout/')
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_form = response.context['order_form']
self.assertGreater(len(order_form.initial), 1)
def view_cart(request):
""" A view that renders the cart content page. """
user = get_object_or_404(UserProfile, user=request.user)
book_preferences_form = UserProfileForm(instance=user)
if request.method == 'POST':
book_preferences_form = (UserProfileForm(request.POST, instance=user))
if book_preferences_form.is_valid():
book_preferences_form.save()
messages.success(request, 'Book Preferences successfully saved')
else:
messages.error(request,
'Update failed. Please, ensure the form is valid')
else:
book_preferences_form = UserProfileForm(instance=user)
context = {
'book_preferences_form': book_preferences_form,
}
return render(request, 'cart/cart.html', context)
def membership_signup(request):
"""Gather information from the user before payment"""
profile = get_object_or_404(UserProfile, user=request.user)
stripe_secret_key = settings.STRIPE_SECRET_KEY
if request.method == 'POST':
form = UserProfileForm(request.POST, request.FILES, instance=profile)
stripe.api_key = stripe_secret_key
if form.is_valid():
# create a customer object in Stripe using form data
subscriber = stripe.Customer.create(
email=request.POST['default_billing_email'],
name=request.POST['default_billing_name'],
address={
'line1': request.POST['default_street_address1'],
'line2': request.POST['default_street_address2'],
'city': request.POST['default_town_or_city'],
'state': request.POST['default_county'],
'postal_code': request.POST['default_postcode'],
'country': request.POST['default_country'],
})
# assign the Stripe customer ID to
# the user's linked userprofile
profile.stripe_customer_id = subscriber.id
form.save()
return redirect(reverse('checkout'))
else:
messages.error(request, 'Please ensure the form is valid.')
else:
form = UserProfileForm(instance=profile)
template = 'memberships/membership_signup.html'
context = {
'profile': profile,
'form': form,
}
return render(request, template, context)
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
})
