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 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 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 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): 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 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 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 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 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): """ 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 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) 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): 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 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 = { '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 """ # 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 = { '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, 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 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_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 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 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 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 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 payment_success(request, order_number): """ Handle successful payments """ save_info = request.session.get('save_info') order = get_object_or_404(Order, order_number=order_number) messages.success( request, f'Order successfully processed! \ Your order number is {order_number}. A confirmation \ email will be sent to {order.email}.') if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) current_cart = cart_contents(request) order.user_profile = profile points_earned = order.order_total * 100 order.points_earned = points_earned profile_points = profile.points profile.points = profile_points + points_earned total_savings = current_cart['savings_total'] order.savings_total = current_cart['savings_total'] profile_savings = profile.total_savings profile.total_savings += total_savings order.save() profile.save() # Save the user's info if save_info: profile_data = { 'default_phone_number': order.phone_number, 'default_country': order.country, 'default_zip_or_post': order.zip_or_post, '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() 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, order_number): # first check whether the user wanted to save their information # by getting that from the session save_info = request.session.get('save_info') # use the order number to get the order created in the previous view # which we'll send back to the template order = get_object_or_404(Order, order_number=order_number) # check if the user is authenticated because if so they'll have a # profile that was created when they created their account. 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. The dictionaries keys will match the # fields on the user profile model. 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, } # create an instance of user profile form, using the profile data # we're going to update the profile we've obtained above and if # the form is valid just save it. user_profile_form = UserProfileForm(profile_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() # attach success message letting user know what their order number is. messages.success( request, f'Order successfully processed! \ Your order number is {order_number}. A confirmation \ email will be sent to {order.email}.') # delete the user shopping bag from the session since it'll no longer # be needed for this session if 'bag' in request.session: del request.session['bag'] # Set the template and the context template = 'checkout/checkout_success.html' context = { 'order': order, } # and render the template. return render(request, template, context)
def checkout_success(request, order_number): """ Handle successful checkouts """ slot = request.session.get('slot', {}) if 'slot' in request.session: s_id = list(slot.keys())[list(slot.values()).index(True)] db_slot = get_object_or_404(Timeslot, pk=s_id) db_slot.available_slots -= 1 db_slot.save() del request.session['slot'] else: messages.error(request, "You need to book a timeslot first!") return redirect('timeslot') 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_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_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}.') 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): """ Handle successful checkouts """ bag = request.session.get('bag', {}) for item, value in bag.items(): items = get_object_or_404(Product, pk=item) quantity = value new_stock = items.stock - quantity items.stock = new_stock items.save() 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, } print(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): """ Handles successful checkouts Args: request: HTTP request order_number: Passes the order number into the function Returns: A successful order made and a toast advising user of the successful purchase and the rendering of the checkout_success template """ 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}. \ Please make a note of this 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, reservation_number): amenities = Amenity.objects.all() save_info = request.session.get('save_info') reservation = get_object_or_404( Reservation, reservation_number=reservation_number) """ When reservations doesn't have stripe_pid Manually trigger send confirmation email function """ if reservation.stripe_pid == '': send_confirmation_email(reservation) """ Save reservation under userprofile is user is authenticated """ if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) reservation.user_profile = profile reservation.save() """ If users check save info, save reservation data in profile """ if save_info: profile_data = { 'default_full_name': reservation.full_name, 'default_email': reservation.email, 'default_phone_number': reservation.phone_number, 'default_country': reservation.country } user_profile_form = UserProfileForm(profile_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() else: messages.error(request, "There was an error with your form. \ Please double check your information.") messages.success(request, f'Reservation successfully processed! \ Your reservation number is {reservation_number}. A confirmation \ email will be sent to {reservation.email}.') template = "checkout/checkout_success.html" context = { "reservation": reservation, "amenities": amenities } return render(request, template, context)
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): # 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 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})