def update(request): """Update contact info""" init_data = {} areas, countries, only_country = get_area_country_options(request) contact = Contact.from_request(request, create=False) if request.POST: new_data = request.POST.copy() form = ExtendedContactInfoForm(countries, areas, new_data, initial=init_data) if form.is_valid(): if contact is None and request.user: contact = Contact(user=request.user) custID = form.save(contact=contact) request.session['custID'] = custID url = urlresolvers.reverse('satchmo_account_info') return http.HttpResponseRedirect(url) else: if config_get_group('NEWSLETTER'): show_newsletter = True else: show_newsletter = False else: if contact: #If a person has their contact info, make sure we populate it in the form for item in contact.__dict__.keys(): init_data[item] = getattr(contact,item) if contact.shipping_address: for item in contact.shipping_address.__dict__.keys(): init_data["ship_"+item] = getattr(contact.shipping_address,item) if contact.billing_address: for item in contact.billing_address.__dict__.keys(): init_data[item] = getattr(contact.billing_address,item) if contact.primary_phone: init_data['phone'] = contact.primary_phone.phone show_newsletter = False current_subscriber = False if config_get_group('NEWSLETTER'): show_newsletter = True if contact: from satchmo.newsletter import is_subscribed current_subscriber = is_subscribed(contact) init_data['newsletter'] = current_subscriber form = ExtendedContactInfoForm(countries, areas, initial=init_data) context = RequestContext(request, { 'form': form, 'country': only_country, 'show_newsletter': show_newsletter}) return render_to_response('contact/update_form.html', context)
def inner_func(request): class Collection: pass checkout_data = Collection() payment_module = config_get_group('PAYMENT_BANKPASSWEB') checkout_data.payment_module = payment_module checkout_data.processor = processing_module.PaymentProcessor( payment_module) # Are we really processing an order? try: order = Order.objects.from_request(request) except Order.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) # Does our order have items in its cart? tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Is our order still valid? if not order.validate(request): context = RequestContext( request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) # Finally call the view checkout_data.order = order checkout_data.cart = tempCart return func(request, checkout_data)
def pay_ship_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) return payship.credit_pay_ship_info(request, config_get_group('PAYMENT_TRUSTCOMMERCE'))
def google_checkout_image_url(parser, token): """ Render the url for a google checkout image. Sample usage:: {% google_checkout_image_url [imagesize] ['transparent'] ['disabled'] %} """ args = token.split_contents() payment_module = config_get_group('PAYMENT_GOOGLE') merchid = payment_module.MERCHANT_ID sizes = CHECKOUT_BUTTON_SIZES.keys() imgsize = "MEDIUM" transparent = False disabled = False locale = None for arg in args[1:]: k = arg.upper() if k == 'TRANSPARENT': transparent = True elif k == 'DISABLED': disabled = True else: if k in sizes: imgsize = k else: raise template.TemplateSyntaxError( "%r tag got an unexpected argument. Perhaps a bad size? Didn't know: %s" % (args[0], arg)) return GoogleCheckoutImageUrlNode(merchid, imgsize, transparent, disabled)
def pay_ship_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) return payship.simple_pay_ship_info(request, config_get_group('PAYMENT_COD'), 'checkout/cod/pay_ship.html')
def google_checkout_image_url(parser, token): """ Render the url for a google checkout image. Sample usage:: {% google_checkout_image_url [imagesize] ['transparent'] ['disabled'] %} """ args = token.split_contents() payment_module = config_get_group('PAYMENT_GOOGLE') merchid = payment_module.MERCHANT_ID sizes = CHECKOUT_BUTTON_SIZES.keys() imgsize = "MEDIUM" transparent = False disabled = False locale = None for arg in args[1:]: k = arg.upper() if k == 'TRANSPARENT': transparent = True elif k == 'DISABLED': disabled = True else: if k in sizes: imgsize = k else: raise template.TemplateSyntaxError("%r tag got an unexpected argument. Perhaps a bad size? Didn't know: %s" % (args[0], arg)) return GoogleCheckoutImageUrlNode(merchid, imgsize, transparent, disabled)
def one_step(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_AUTOSUCCESS') #First verify that the customer exists try: contact = Contact.objects.from_request(request, create=False) except Contact.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) #Verify we still have items in the cart if cart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Create a new order newOrder = Order(contact=contact) pay_ship_save(newOrder, cart, contact, shipping="", discount="") request.session['orderID'] = newOrder.id newOrder.add_status(status='Pending', notes="Order successfully submitted") record_payment(newOrder, payment_module, amount=newOrder.balance) tempCart.empty() success = lookup_url(payment_module, 'satchmo_checkout-success') return HttpResponseRedirect(success)
def register(request, redirect=None, template='registration/registration_form.html'): """ Allows a new user to register an account. """ ret = register_handle_form(request, redirect) success = ret[0] todo = ret[1] if len(ret) > 2: extra_context = ret[2] else: extra_context = {} if success: return todo else: if config_get_group('NEWSLETTER'): show_newsletter = True else: show_newsletter = False ctx = { 'form': todo, 'title' : _('Registration Form'), 'show_newsletter' : show_newsletter } if extra_context: ctx.update(extra_context) context = RequestContext(request, ctx) return render_to_response(template, context)
def pay_ship_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) return payship.credit_pay_ship_info(request, config_get_group('PAYMENT_AUTHORIZENET'))
def confirm_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) return confirm.credit_confirm_info(request, config_get_group('PAYMENT_CYBERSOURCE'))
def one_step(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_AUTOSUCCESS') #First verify that the customer exists try: contact = Contact.objects.from_request(request, create=False) except Contact.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) #Verify we still have items in the cart if cart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Create a new order newOrder = Order(contact=contact) pay_ship_save(newOrder, cart, contact, shipping="", discount="") request.session['orderID'] = newOrder.id newOrder.add_status(status='Pending', notes = "Order successfully submitted") record_payment(newOrder, payment_module, amount=newOrder.balance) tempCart.empty() success = lookup_url(payment_module, 'satchmo_checkout-success') return HttpResponseRedirect(success)
def inner_func(request): class Collection: pass checkout_data = Collection() payment_module = config_get_group('PAYMENT_BANKPASSWEB') checkout_data.payment_module = payment_module checkout_data.processor = processing_module.PaymentProcessor(payment_module) # Are we really processing an order? try: order = Order.objects.from_request(request) except Order.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) # Does our order have items in its cart? tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Is our order still valid? if not order.validate(request): context = RequestContext(request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) # Finally call the view checkout_data.order = order checkout_data.cart = tempCart return func(request, checkout_data)
def confirm_info(request, template='checkout/protx/confirm.html', extra_context={}): payment_module = config_get_group('PAYMENT_PROTX') controller = confirm.ConfirmController(request, payment_module) controller.templates['CONFIRM'] = template controller.extra_context = extra_context controller.onForm = secure3d_form_handler controller.confirm() return controller.response
def cost(self): """ Complex calculations can be done here as long as the return value is a decimal figure """ assert(self._calculated) settings = config_get_group('satchmo.shipping.modules.usps') if settings.HANDLING_FEE and float(str(settings.HANDLING_FEE)) > 0.0: self.charges = Decimal(self.charges) + Decimal(str(settings.HANDLING_FEE)) return Decimal(str(self.charges))
def payment_label(value): """convert a payment key into its translated text""" payments = config_get("PAYMENT", "MODULES") for mod in payments.value: config = config_get_group(mod) if config.KEY.value == value: return translation.ugettext(config.LABEL) return value.capitalize()
def payment_label(value): """convert a payment key into its translated text""" payments = config_get("PAYMENT", "MODULES") for mod in payments.value: config = config_get_group(mod) if config.KEY.value == value: return translation.ugettext(unicode(config.LABEL)) return value.capitalize()
def contact_info(request): """View which collects demographic information from customer.""" #First verify that the cart exists and has items if request.session.get('cart'): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: return render_to_response('checkout/empty_cart.html', RequestContext(request)) else: return render_to_response('checkout/empty_cart.html', RequestContext(request)) init_data = {} areas, countries, only_country = get_area_country_options(request) contact = Contact.from_request(request, create=False) if request.POST: new_data = request.POST.copy() if not tempCart.is_shippable: new_data['copy_address'] = True form = PaymentContactInfoForm(countries, areas, new_data, initial=init_data) if form.is_valid(): if contact is None and request.user: contact = Contact(user=request.user) custID = form.save(contact=contact, update_newsletter=False) request.session['custID'] = custID #TODO - Create an order here and associate it with a session modulename = 'PAYMENT_' + new_data['paymentmethod'] paymentmodule = config_get_group(modulename) url = lookup_url(paymentmodule, 'satchmo_checkout-step2') return http.HttpResponseRedirect(url) else: if contact: #If a person has their contact info, make sure we populate it in the form for item in contact.__dict__.keys(): init_data[item] = getattr(contact,item) if contact.shipping_address: for item in contact.shipping_address.__dict__.keys(): init_data["ship_"+item] = getattr(contact.shipping_address,item) if contact.billing_address: for item in contact.billing_address.__dict__.keys(): init_data[item] = getattr(contact.billing_address,item) if contact.primary_phone: init_data['phone'] = contact.primary_phone.phone else: # Allow them to login from this page. request.session.set_test_cookie() form = PaymentContactInfoForm(countries, areas, initial=init_data) context = RequestContext(request, { 'form': form, 'country': only_country, 'paymentmethod_ct': len(config_value('PAYMENT', 'MODULES')) }) return render_to_response('checkout/form.html', context)
def one_step(request): payment_module = config_get_group('PAYMENT_AUTOSUCCESS') #First verify that the customer exists contact = Contact.from_request(request, create=False) if contact is None: url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) #Verify we still have items in the cart if request.session.get('cart', False): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) else: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Create a new order newOrder = Order(contact=contact) pay_ship_save(newOrder, tempCart, contact, shipping="", discount="") request.session['orderID'] = newOrder.id newOrder.add_status(status='Pending', notes="Order successfully submitted") orderpayment = OrderPayment(order=newOrder, amount=newOrder.balance, payment=payment_module.KEY.value) orderpayment.save() #Now, send a confirmation email if payment_module['EMAIL'].value: shop_config = Config.get_shop_config() shop_email = shop_config.store_email shop_name = shop_config.store_name t = loader.get_template('email/order_complete.txt') c = Context({'order': newOrder, 'shop_name': shop_name}) subject = "Thank you for your order from %s" % shop_name try: email = orderToProcess.contact.email body = t.render(c) send_mail(subject, body, shop_email, [email], fail_silently=False) except SocketError, e: if settings.DEBUG: log.error('Error sending mail: %s' % e) log.warn( 'Ignoring email error, since you are running in DEBUG mode. Email was:\nTo:%s\nSubject: %s\n---\n%s', email, subject, body) else: log.fatal('Error sending mail: %s' % e) raise IOError( 'Could not send email, please check to make sure your email settings are correct, and that you are not being blocked by your ISP.' )
def pay_ship_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) return payship.credit_pay_ship_info( request, config_get_group('PAYMENT_PROTX'), template="checkout/protx/pay_ship.html")
def cost(self): """ Complex calculations can be done here as long as the return value is a decimal figure """ assert (self._calculated) settings = config_get_group('satchmo.shipping.modules.usps') if settings.HANDLING_FEE and float(str(settings.HANDLING_FEE)) > 0.0: self.charges = Decimal(self.charges) + Decimal( str(settings.HANDLING_FEE)) return Decimal(str(self.charges))
def contact_info(request): """View which collects demographic information from customer.""" # First verify that the cart exists and has items if request.session.get("cart"): tempCart = Cart.objects.get(id=request.session["cart"]) if tempCart.numItems == 0: return render_to_response("checkout/empty_cart.html", RequestContext(request)) else: return render_to_response("checkout/empty_cart.html", RequestContext(request)) init_data = {} areas, countries, only_country = get_area_country_options(request) contact = Contact.from_request(request, create=False) if request.POST: new_data = request.POST.copy() if not tempCart.is_shippable: new_data["copy_address"] = True form = PaymentContactInfoForm(countries, areas, new_data, initial=init_data) if form.is_valid(): if contact is None and request.user: contact = Contact(user=request.user) custID = form.save(contact=contact, update_newsletter=False) request.session["custID"] = custID # TODO - Create an order here and associate it with a session modulename = "PAYMENT_" + new_data["paymentmethod"] paymentmodule = config_get_group(modulename) url = lookup_url(paymentmodule, "satchmo_checkout-step2") return http.HttpResponseRedirect(url) else: if contact: # If a person has their contact info, make sure we populate it in the form for item in contact.__dict__.keys(): init_data[item] = getattr(contact, item) if contact.shipping_address: for item in contact.shipping_address.__dict__.keys(): init_data["ship_" + item] = getattr(contact.shipping_address, item) if contact.billing_address: for item in contact.billing_address.__dict__.keys(): init_data[item] = getattr(contact.billing_address, item) if contact.primary_phone: init_data["phone"] = contact.primary_phone.phone else: # Allow them to login from this page. request.session.set_test_cookie() form = PaymentContactInfoForm(countries, areas, initial=init_data) context = RequestContext( request, {"form": form, "country": only_country, "paymentmethod_ct": len(config_value("PAYMENT", "MODULES"))} ) return render_to_response("checkout/form.html", context)
def confirm_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_GOOGLE') if not 'orderID' in request.session: url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) try: order = Order.objects.from_request(request) except Order.DoesNotExist: order = None if not (order and order.validate(request)): context = RequestContext( request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) live = payment_live(payment_module) gcart = GoogleCart(order, payment_module, live) log.debug("CART:\n%s", gcart.cart_xml) template = lookup_template(payment_module, 'checkout/google/confirm.html') if live: merchant_id = payment_module.MERCHANT_ID.value url_template = payment_module.POST_URL.value else: merchant_id = payment_module.MERCHANT_TEST_ID.value url_template = payment_module.POST_TEST_URL.value post_url = url_template % {'MERCHANT_ID': merchant_id} default_view_tax = config_value('TAX', 'DEFAULT_VIEW_TAX') ctx = RequestContext( request, { 'order': order, 'post_url': post_url, 'default_view_tax': default_view_tax, 'google_cart': gcart.encoded_cart(), 'google_signature': gcart.encoded_signature(), 'PAYMENT_LIVE': live }) return render_to_response(template, ctx)
def checkout_image_url(merchid, imgsize, locale, transparent=False, disabled=False): payment_module = config_get_group('PAYMENT_GOOGLE') dimensions = CHECKOUT_BUTTON_SIZES[imgsize] return ("%s?%s" % ( payment_module.CHECKOUT_BUTTON_URL, urlencode((('merchant_id', merchid), ('w', dimensions[0]), ('h', dimensions[1]), ('style', _truefalse(transparent, t="trans", f="white")), ('variant', _truefalse(disabled, t="disabled", f="text")), ('loc', locale)))))
def render_template(self, template, cart=None, contact=None): from satchmo.shop.models import Config shop_details = Config.objects.get_current() settings = config_get_group('satchmo.shipping.modules.usps') if not self.is_intl: mail_type = CODES[self.service_type_code] if mail_type == 'INTL': return '' if mail_type == 'FIRST CLASS': self.api = None else: self.api = APIS[mail_type] else: mail_type = None self.api = None # calculate the weight of the entire order weight = Decimal('0.0') for item in cart.cartitem_set.all(): if item.product.weight: weight += item.product.weight * item.quantity self.verbose_log('WEIGHT: %s' % weight) # I don't know why USPS made this one API different this way... if self.api == 'ExpressMailCommitment': zip_ending = 'ZIP' else: zip_ending = 'zip' # get the shipping country (for the international orders) ship_country = contact.shipping_address.country.printable_name configuration = { 'userid': settings.USER_ID.value, 'password': settings.USER_PASSWORD.value, 'container': settings.SHIPPING_CONTAINER.value, 'ship_type': mail_type, 'shop_details': shop_details } c = Context({ 'config': configuration, 'cart': cart, 'contact': contact, 'is_international': self.is_intl, 'api': self.api, 'weight': weight, 'zip': zip_ending, 'country': ship_country, 'first_class_types': ['LETTER', 'FLAT', 'PARCEL'] }) t = loader.get_template(template) return t.render(c)
def apply_to_order(self, order): """Apply up to the full amount of the balance of this cert to the order. Returns new balance. """ amount = min(order.balance, self.balance) log.info('applying %s from giftcert #%i [%s] to order #%i [%s]', money_format(amount), self.id, money_format(self.balance), order.id, money_format(order.balance)) config = config_get_group('PAYMENT_GIFTCERTIFICATE') orderpayment = record_payment(order, config, amount) return self.use(amount, orderpayment=orderpayment)
def render_template(self, template, cart=None, contact=None): from satchmo.shop.models import Config shop_details = Config.objects.get_current() settings = config_get_group('satchmo.shipping.modules.usps') if not self.is_intl: mail_type = CODES[self.service_type_code] if mail_type == 'INTL': return '' if mail_type == 'FIRST CLASS': self.api = None else: self.api = APIS[mail_type] else: mail_type = None self.api = None # calculate the weight of the entire order weight = Decimal('0.0') for item in cart.cartitem_set.all(): if item.product.weight: weight += item.product.weight * item.quantity self.verbose_log('WEIGHT: %s' % weight) # I don't know why USPS made this one API different this way... if self.api == 'ExpressMailCommitment': zip_ending = 'ZIP' else: zip_ending = 'zip' # get the shipping country (for the international orders) ship_country = contact.shipping_address.country.printable_name configuration = { 'userid': settings.USER_ID.value, 'password': settings.USER_PASSWORD.value, 'container': settings.SHIPPING_CONTAINER.value, 'ship_type': mail_type, 'shop_details': shop_details } c = Context({ 'config': configuration, 'cart': cart, 'contact': contact, 'is_international': self.is_intl, 'api': self.api, 'weight': weight, 'zip': zip_ending, 'country': ship_country, 'first_class_types': ['LETTER', 'FLAT', 'PARCEL'] }) t = loader.get_template(template) return t.render(c)
def confirm_secure3d(request, secure3d_template='checkout/secure3d_form.html', confirm_template='checkout/confirm.html', extra_context={}): """Handles confirming an order and processing the charges when secured by secure3d. """ # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_PROTX') controller = confirm.ConfirmController(request, payment_module, extra_context=extra_context) controller.template['CONFIRM'] = confirm_template if not controller.sanity_check(): return controller.response auth3d = request.session.get('3D', None) if not auth3d: controller.processorMessage = _( '3D Secure transaction expired. Please try again.') else: if request.method == "POST": returnMD = request.POST.get('MD', None) if not returnMD: template = payment_module.lookup_template(secure3d_template) ctx = {'order': controller.order, 'auth': auth3d} return render_to_response(template, ctx, RequestContext(request)) elif returnMD == auth3d['MD']: pares = request.POST.get('PaRes', None) controller.processor.prepareData(controller.order) controller.processor.prepareData3d(returnMD, pares) if controller.process(): return controller.onSuccess(controller) else: controller.processorMessage = _( '3D Secure transaction was not approved by payment gateway. Please contact us.' ) else: template = lookup_template(payment_module, secure3d_template) ctx = RequestContext(request, { 'order': controller.order, 'auth': auth3d }) return render_to_response(template, ctx) return secure3d_form_handler(controller)
def confirm_info(request): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_GOOGLE') if not 'orderID' in request.session: url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) try: order = Order.objects.from_request(request) except Order.DoesNotExist: order = None if not (order and order.validate(request)): context = RequestContext(request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) live = payment_live(payment_module) gcart = GoogleCart(order, payment_module, live) log.debug("CART:\n%s", gcart.cart_xml) template = lookup_template(payment_module, 'checkout/google/confirm.html') if live: merchant_id = payment_module.MERCHANT_ID.value url_template = payment_module.POST_URL.value else: merchant_id = payment_module.MERCHANT_TEST_ID.value url_template = payment_module.POST_TEST_URL.value post_url = url_template % {'MERCHANT_ID' : merchant_id} default_view_tax = config_value('TAX', 'DEFAULT_VIEW_TAX') ctx = RequestContext(request, { 'order': order, 'post_url': post_url, 'default_view_tax': default_view_tax, 'google_cart' : gcart.encoded_cart(), 'google_signature' : gcart.encoded_signature(), 'PAYMENT_LIVE' : live }) return render_to_response(template, ctx)
def one_step(request): payment_module = config_get_group('PAYMENT_AUTOSUCCESS') #First verify that the customer exists contact = Contact.from_request(request, create=False) if contact is None: url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) #Verify we still have items in the cart if request.session.get('cart', False): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) else: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Create a new order newOrder = Order(contact=contact) pay_ship_save(newOrder, tempCart, contact, shipping="", discount="") request.session['orderID'] = newOrder.id newOrder.add_status(status='Pending', notes = "Order successfully submitted") orderpayment = OrderPayment(order=newOrder, amount=newOrder.balance, payment=payment_module.KEY.value) orderpayment.save() #Now, send a confirmation email if payment_module['EMAIL'].value: shop_config = Config.get_shop_config() shop_email = shop_config.store_email shop_name = shop_config.store_name t = loader.get_template('email/order_complete.txt') c = Context({'order': newOrder, 'shop_name': shop_name}) subject = "Thank you for your order from %s" % shop_name try: email = orderToProcess.contact.email body = t.render(c) send_mail(subject, body, shop_email, [email], fail_silently=False) except SocketError, e: if settings.DEBUG: log.error('Error sending mail: %s' % e) log.warn('Ignoring email error, since you are running in DEBUG mode. Email was:\nTo:%s\nSubject: %s\n---\n%s', email, subject, body) else: log.fatal('Error sending mail: %s' % e) raise IOError('Could not send email, please check to make sure your email settings are correct, and that you are not being blocked by your ISP.')
def confirm_info(request): payment_module = config_get_group('PAYMENT_GOOGLE') if not request.session.get('orderID'): url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) if request.session.get('cart'): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) else: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) order = Order.objects.get(id=request.session['orderID']) # Check if the order is still valid if not order.validate(request): context = RequestContext( request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) live = payment_live(payment_module) gcart = GoogleCart(order, payment_module, live) log.debug("CART:\n%s", gcart.cart_xml) template = lookup_template(payment_module, 'checkout/google/confirm.html') if live: merchant_id = payment_module.MERCHANT_ID.value url_template = payment_module.POST_URL.value else: merchant_id = payment_module.MERCHANT_TEST_ID.value url_template = payment_module.POST_TEST_URL.value post_url = url_template % {'MERCHANT_ID': merchant_id} ctx = RequestContext( request, { 'order': order, 'post_url': post_url, 'google_cart': gcart.encoded_cart(), 'google_signature': gcart.encoded_signature(), 'PAYMENT_LIVE': live }) return render_to_response(template, ctx)
def confirm_info(request, template='checkout/protx/confirm.html', extra_context={}): # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) payment_module = config_get_group('PAYMENT_PROTX') controller = confirm.ConfirmController(request, payment_module) controller.templates['CONFIRM'] = template controller.extra_context = extra_context controller.onForm = secure3d_form_handler controller.confirm() return controller.response
def apply_to_order(self, order): """Apply up to the full amount of the balance of this cert to the order. Returns new balance. """ amount = min(order.balance, self.balance) log.info('applying %s from giftcert #%i [%s] to order #%i [%s]', money_format(amount), self.id, money_format(self.balance), order.id, money_format(order.balance)) config = config_get_group('PAYMENT_GIFTCERTIFICATE') orderpayment = record_payment(order, config, amount) return self.use(amount, orderpayment=orderpayment)
def checkout_image_url(merchid, imgsize, locale, transparent=False, disabled=False): payment_module = config_get_group('PAYMENT_GOOGLE') dimensions = CHECKOUT_BUTTON_SIZES[imgsize] return ("%s?%s" % (payment_module.CHECKOUT_BUTTON_URL, urlencode( (('merchant_id', merchid), ('w', dimensions[0]), ('h', dimensions[1]), ('style', _truefalse(transparent, t="trans", f="white")), ('variant', _truefalse(disabled, t="disabled", f="text")), ('loc', locale)))))
def confirm_info(request): payment_module = config_get_group('PAYMENT_PAYPAL') if not request.session.get('orderID'): url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) if request.session.get('cart'): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) else: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) order = Order.objects.get(id=request.session['orderID']) # Check if the order is still valid if not order.validate(request): context = RequestContext(request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) template = lookup_template(payment_module, 'checkout/paypal/confirm.html') if payment_module.LIVE.value: log.debug("live order on %s", payment_module.KEY.value) url = payment_module.POST_URL.value account = payment_module.BUSINESS.value else: url = payment_module.POST_TEST_URL.value account = payment_module.BUSINESS_TEST.value try: address = lookup_url(payment_module, payment_module.RETURN_ADDRESS.value, include_server=True) except urlresolvers.NoReverseMatch: address = payment_module.RETURN_ADDRESS.value ctx = RequestContext(request, {'order': order, 'post_url': url, 'business': account, 'currency_code': payment_module.CURRENCY_CODE.value, 'return_address': address, 'PAYMENT_LIVE' : payment_live(payment_module) }) return render_to_response(template, ctx)
def confirm_info(request): payment_module = config_get_group('PAYMENT_GOOGLE') if not request.session.get('orderID'): url = lookup_url(payment_module, 'satchmo_checkout-step1') return http.HttpResponseRedirect(url) if request.session.get('cart'): tempCart = Cart.objects.get(id=request.session['cart']) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) else: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) order = Order.objects.get(id=request.session['orderID']) # Check if the order is still valid if not order.validate(request): context = RequestContext(request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) live = payment_live(payment_module) gcart = GoogleCart(order, payment_module, live) log.debug("CART:\n%s", gcart.cart_xml) template = lookup_template(payment_module, 'checkout/google/confirm.html') if live: merchant_id = payment_module.MERCHANT_ID.value url_template = payment_module.POST_URL.value else: merchant_id = payment_module.MERCHANT_TEST_ID.value url_template = payment_module.POST_TEST_URL.value post_url = url_template % {'MERCHANT_ID' : merchant_id} ctx = RequestContext(request, { 'order': order, 'post_url': post_url, 'google_cart' : gcart.encoded_cart(), 'google_signature' : gcart.encoded_signature(), 'PAYMENT_LIVE' : live }) return render_to_response(template, ctx)
def register(request, redirect=None, template='registration/registration_form.html'): """ Allows a new user to register an account. """ success, todo = register_handle_form(request, redirect=redirect) if success: return todo else: if config_get_group('NEWSLETTER'): show_newsletter = True else: show_newsletter = False context = RequestContext(request, { 'form': todo, 'title' : _('Registration Form'), 'show_newsletter' : show_newsletter }) return render_to_response(template, context)
def config_tax(): TAX_MODULE = config_get('TAX', 'MODULE') TAX_MODULE.add_choice(('satchmo.tax.modules.area', _('By Country/Area'))) TAX_GROUP = config_get_group('TAX') _tax_classes = [] ship_default = "" try: for tax in TaxClass.objects.all(): _tax_classes.append((tax.title, tax)) if "ship" in tax.title.lower(): ship_default = tax.title except: log.warn("Ignoring database error retrieving tax classes - OK if you are in syncdb.") if ship_default == "" and len(_tax_classes) > 0: ship_default = _tax_classes[0][0] config_register( BooleanValue( TAX_GROUP, 'TAX_SHIPPING', description=_("Tax Shipping?"), requires=TAX_MODULE, requiresvalue='satchmo.tax.modules.area', default=False ) ) config_register( StringValue( TAX_GROUP, 'TAX_CLASS', description=_("TaxClass for shipping"), help_text=_("Select a TaxClass that should be applied for shipments."), default=ship_default, choices=_tax_classes ) )
def confirm_info(request): """Shows the user its order details and ask confirmation to send to the real payment function""" payment_module = config_get_group('PAYMENT_PAYPAL_EXPRESS') try: order = Order.objects.from_request(request) except Order.DoesNotExist: url = lookup_url(payment_module, 'satchmo_checkout-step1') return HttpResponseRedirect(url) tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: template = lookup_template(payment_module, 'checkout/empty_cart.html') return render_to_response(template, RequestContext(request)) # Check if the order is still valid if not order.validate(request): context = RequestContext(request, {'message': _('Your order is no longer valid.')}) return render_to_response('shop_404.html', context) template = lookup_template(payment_module, 'checkout/paypal_express/confirm.html') create_pending_payment(order, payment_module) default_view_tax = config_value('TAX', 'DEFAULT_VIEW_TAX') recurring = None order_items = order.orderitem_set.all() ctx = RequestContext(request, {'order': order, 'post_url': urlresolvers.reverse("PAYPAL_EXPRESS_satchmo_checkout-step4"), 'default_view_tax': default_view_tax, 'currency_code': payment_module.CURRENCY_CODE.value, 'invoice': order.id, }) return render_to_response(template, ctx)
def confirm_secure3d(request, secure3d_template='checkout/secure3d_form.html', confirm_template='checkout/confirm.html', extra_context={}): """Handles confirming an order and processing the charges when secured by secure3d. """ payment_module = config_get_group('PAYMENT_PROTX') controller = confirm.ConfirmController(request, payment_module, extra_context=extra_context) controller.template['CONFIRM'] = confirm_template if not controller.sanity_check(): return controller.response auth3d = request.session.get('3D', None) if not auth3d: controller.processorMessage = _('3D Secure transaction expired. Please try again.') else: if request.method == "POST": returnMD = request.POST.get('MD', None) if not returnMD: template = payment_module.lookup_template(secure3d_template) ctx ={'order': controller.order, 'auth': auth3d } return render_to_response(template, ctx, RequestContext(request)) elif returnMD == auth3d['MD']: pares = request.POST.get('PaRes', None) controller.processor.prepareData(controller.order) controller.processor.prepareData3d(returnMD, pares) if controller.process(): return controller.onSuccess(controller) else: controller.processorMessage = _('3D Secure transaction was not approved by payment gateway. Please contact us.') else: template = lookup_template(payment_module, secure3d_template) ctx =RequestContext(request, { 'order': controller.order, 'auth': auth3d }) return render_to_response(template, ctx) return secure3d_form_handler(controller)
def view(request): """View contact info.""" try: user_data = Contact.objects.get(user=request.user.id) except Contact.DoesNotExist: user_data = None show_newsletter = False newsletter = False if config_get_group('NEWSLETTER'): show_newsletter = True from satchmo.newsletter import is_subscribed if user_data: newsletter = is_subscribed(user_data) context = RequestContext(request, { 'user_data': user_data, 'show_newsletter' : show_newsletter, 'newsletter' : newsletter }) return render_to_response('contact/view_profile.html', context)
def balance_remaining(request): """Allow the user to pay the remaining balance.""" order = None orderid = request.session.get('orderID') if orderid: try: order = Order.objects.get(pk=orderid) except Order.DoesNotExist: # TODO: verify user against current user pass if not order: url = urlresolvers.reverse('satchmo_checkout-step1') return HttpResponseRedirect(url) if request.method == "POST": new_data = request.POST.copy() form = PaymentMethodForm(new_data, order=order) if form.is_valid(): data = form.cleaned_data modulename = data['paymentmethod'] if not modulename.startswith('PAYMENT_'): modulename = 'PAYMENT_' + modulename paymentmodule = config_get_group(modulename) url = lookup_url(paymentmodule, 'satchmo_checkout-step2') return HttpResponseRedirect(url) else: form = PaymentMethodForm(order=order) ctx = RequestContext( request, { 'form': form, 'order': order, 'paymentmethod_ct': len(config_value('PAYMENT', 'MODULES')) }) return render_to_response('checkout/balance_remaining.html', ctx)
def config_tax(): TAX_MODULE = config_get('TAX', 'MODULE') TAX_MODULE.add_choice(('satchmo.tax.modules.area', _('By Country/Area'))) TAX_GROUP = config_get_group('TAX') _tax_classes = [] ship_default = "" try: for tax in TaxClass.objects.all(): _tax_classes.append((tax.title, tax)) if "ship" in tax.title.lower(): ship_default = tax.title except: log.warn( "Ignoring database error retrieving tax classes - OK if you are in syncdb." ) if ship_default == "" and len(_tax_classes) > 0: ship_default = _tax_classes[0][0] config_register( BooleanValue(TAX_GROUP, 'TAX_SHIPPING', description=_("Tax Shipping?"), requires=TAX_MODULE, requiresvalue='satchmo.tax.modules.area', default=False)) config_register( StringValue( TAX_GROUP, 'TAX_CLASS', description=_("TaxClass for shipping"), help_text=_( "Select a TaxClass that should be applied for shipments."), default=ship_default, choices=_tax_classes))
def register(request, redirect=None, template='registration/registration_form.html'): """ Allows a new user to register an account. """ success, todo = register_handle_form(request, redirect=redirect) if success: return todo else: if config_get_group('NEWSLETTER'): show_newsletter = True else: show_newsletter = False context = RequestContext( request, { 'form': todo, 'title': _('Registration Form'), 'show_newsletter': show_newsletter }) return render_to_response(template, context)
def balance_remaining(request): """Allow the user to pay the remaining balance.""" order = None orderid = request.session.get('orderID') if orderid: try: order = Order.objects.get(pk=orderid) except Order.DoesNotExist: # TODO: verify user against current user pass if not order: url = urlresolvers.reverse('satchmo_checkout-step1') return HttpResponseRedirect(url) if request.method == "POST": new_data = request.POST.copy() form = PaymentMethodForm(new_data, order=order) if form.is_valid(): data = form.cleaned_data modulename = data['paymentmethod'] if not modulename.startswith('PAYMENT_'): modulename = 'PAYMENT_' + modulename paymentmodule = config_get_group(modulename) url = lookup_url(paymentmodule, 'satchmo_checkout-step2') return HttpResponseRedirect(url) else: form = PaymentMethodForm(order=order) ctx = RequestContext(request, { 'form': form, 'order': order, 'paymentmethod_ct': len(config_value('PAYMENT', 'MODULES')) }) return render_to_response('checkout/balance_remaining.html', ctx)
from django.conf.urls.defaults import * from satchmo.configuration import config_value, config_get_group config = config_get_group('PAYMENT_DUMMY') urlpatterns = patterns( 'satchmo', (r'^$', 'payment.modules.dummy.views.pay_ship_info', { 'SSL': config.SSL.value }, 'DUMMY_satchmo_checkout-step2'), (r'^confirm/$', 'payment.modules.dummy.views.confirm_info', { 'SSL': config.SSL.value }, 'DUMMY_satchmo_checkout-step3'), (r'^success/$', 'payment.common.views.checkout.success', { 'SSL': config.SSL.value }, 'DUMMY_satchmo_checkout-success'), )
from django.conf.urls.defaults import * from satchmo.configuration import config_value, config_get_group config = config_get_group('PAYMENT_AUTHORIZENET') urlpatterns = patterns('satchmo', (r'^$', 'payment.modules.authorizenet.views.pay_ship_info', {'SSL':config.SSL.value}, 'AUTHORIZENET_satchmo_checkout-step2'), (r'^confirm/$', 'payment.modules.authorizenet.views.confirm_info', {'SSL':config.SSL.value}, 'AUTHORIZENET_satchmo_checkout-step3'), (r'^success/$', 'payment.common.views.checkout.success', {'SSL':config.SSL.value}, 'AUTHORIZENET_satchmo_checkout-success'), )
sampleOrder = testOrder() sampleOrder.contact.first_name = 'Dan' sampleOrder.contact.last_name = 'Lim' sampleOrder.contact.primary_phone = '212-353-1713' sampleOrder.full_bill_street = '130 West 25th St' sampleOrder.bill_postal_code = '10001' sampleOrder.bill_state = 'NY' sampleOrder.bill_city = 'New York' sampleOrder.bill_country = 'US' sampleOrder.total = "1.05" sampleOrder.balance = "1.05" sampleOrder.credit_card.decryptedCC = '376750290511001' sampleOrder.credit_card.expirationDate = "06/10" sampleOrder.credit_card.ccv = "9207" #this needed to be added -Pete sampleOrder.paid_in_full = False sampleOrder.credit_card.display_cc = sampleOrder.credit_card.decryptedCC sampleOrder.id = 5 authorize_settings = config_get_group('PAYMENT_AUTHORIZENET') if authorize_settings.LIVE.value: print "Warning. You are submitting a live order. AUTHORIZE.NET system is set LIVE." processor = PaymentProcessor(authorize_settings) processor.prepareData(sampleOrder) results, reason_code, msg = processor.process(testing=True) print results,"::", msg
def save(self, contact=None, update_newsletter=True): """Save the contact info into the database. Checks to see if contact exists. If not, creates a contact and copies in the address and phone number.""" if not contact: customer = Contact() else: customer = contact data = self.cleaned_data for field in customer.__dict__.keys(): try: setattr(customer, field, data[field]) except KeyError: pass if update_newsletter and config_get_group('NEWSLETTER'): from satchmo.newsletter import update_subscription if 'newsletter' not in data: subscribed = False else: subscribed = data['newsletter'] update_subscription(contact, subscribed) if not customer.role: customer.role = "Customer" customer.save() # we need to make sure we don't blindly add new addresses # this isn't ideal, but until we have a way to manage addresses # this will force just the two addresses, shipping and billing # TODO: add address management like Amazon. bill_address = customer.billing_address if not bill_address: bill_address = AddressBook(contact=customer) address_keys = bill_address.__dict__.keys() for field in address_keys: try: setattr(bill_address, field, data[field]) except KeyError: pass bill_address.is_default_billing = True copy_address = data['copy_address'] ship_address = customer.shipping_address if copy_address: # make sure we don't have any other default shipping address if ship_address and ship_address.id != bill_address.id: ship_address.delete() bill_address.is_default_shipping = True bill_address.save() if not copy_address: if not ship_address or ship_address.id == bill_address.id: ship_address = AddressBook() for field in address_keys: try: setattr(ship_address, field, data['ship_' + field]) except KeyError: pass ship_address.is_default_shipping = True ship_address.is_default_billing = False ship_address.contact = customer ship_address.country = bill_address.country ship_address.save() if not customer.primary_phone: phone = PhoneNumber() phone.primary = True else: phone = customer.primary_phone phone.phone = data['phone'] phone.contact = customer phone.save() return customer.id
from django.conf.urls import patterns, url from satchmo.configuration import config_get_group, config_get, config_value import logging log = logging.getLogger(__name__) config = config_get_group('PAYMENT') urlpatterns = patterns( 'satchmo.payment.views', (r'^$', 'contact.contact_info_view', {}, 'satchmo_checkout-step1'), (r'custom/charge/(?P<orderitem_id>\d+)/$', 'balance.charge_remaining', {}, 'satchmo_charge_remaining'), (r'custom/charge/$', 'balance.charge_remaining_post', {}, 'satchmo_charge_remaining_post'), (r'^balance/(?P<order_id>\d+)/$', 'balance.balance_remaining_order', {}, 'satchmo_balance_remaining_order'), (r'^balance/$', 'balance.balance_remaining', {}, 'satchmo_balance_remaining'), (r'^cron/$', 'cron.cron_rebill', {}, 'satchmo_cron_rebill'), (r'^mustlogin/$', 'contact.authentication_required', {}, 'satchmo_checkout_auth_required'), ) # Now add all enabled module payment settings def make_urlpatterns(): patterns = [] for key in config_value('PAYMENT', 'MODULES'): cfg = config_get(key, 'MODULE') modulename = cfg.editor_value
from django.conf.urls import * from satchmo.configuration import config_get_group config = config_get_group('PAYMENT_PURCHASEORDER') urlpatterns = patterns( 'satchmo.payment', (r'^$', 'modules.purchaseorder.views.pay_ship_info', {}, 'PURCHASEORDER_satchmo_checkout-step2'), (r'^confirm/$', 'modules.purchaseorder.views.confirm_info', {}, 'PURCHASEORDER_satchmo_checkout-step3'), (r'^success/$', 'views.checkout.success', {}, 'PURCHASEORDER_satchmo_checkout-success'), )
from django.conf.urls.defaults import * from satchmo.configuration import config_get_group config = config_get_group('PAYMENT_GIFTCERTIFICATE') urlpatterns = patterns('satchmo', (r'^$', 'giftcertificate.views.pay_ship_info', {'SSL':config.SSL.value}, 'GIFTCERTIFICATE_satchmo_checkout-step2'), (r'^confirm/$', 'giftcertificate.views.confirm_info', {'SSL':config.SSL.value}, 'GIFTCERTIFICATE_satchmo_checkout-step3'), (r'^success/$', 'payment.views.checkout.success', {'SSL':config.SSL.value}, 'GIFTCERTIFICATE_satchmo_checkout-success'), (r'^balance/$', 'giftcertificate.views.check_balance', {}, 'satchmo_giftcertificate_balance'), )
def contact_info(request, **kwargs): """View which collects demographic information from customer.""" #First verify that the cart exists and has items tempCart = Cart.objects.from_request(request) if tempCart.numItems == 0: return render_to_response('checkout/empty_cart.html', RequestContext(request)) init_data = {} shop = Config.objects.get_current() if request.user.email: init_data['email'] = request.user.email if request.user.first_name: init_data['first_name'] = request.user.first_name if request.user.last_name: init_data['last_name'] = request.user.last_name try: contact = Contact.objects.from_request(request, create=False) except Contact.DoesNotExist: contact = None # Check that items are in stock cart = Cart.objects.from_request(request) if cart.not_enough_stock(): return http.HttpResponseRedirect(urlresolvers.reverse("satchmo_cart")) if request.method == "POST": new_data = request.POST.copy() if not tempCart.is_shippable: new_data['copy_address'] = True form = PaymentContactInfoForm(new_data, shop=shop, contact=contact, shippable=tempCart.is_shippable, initial=init_data, cart=tempCart) if form.is_valid(): if contact is None and request.user and request.user.is_authenticated( ): contact = Contact(user=request.user) custID = form.save(contact=contact) request.session[CUSTOMER_ID] = custID #TODO - Create an order here and associate it with a session modulename = new_data['paymentmethod'] if not modulename.startswith('PAYMENT_'): modulename = 'PAYMENT_' + modulename paymentmodule = config_get_group(modulename) url = lookup_url(paymentmodule, 'satchmo_checkout-step2') return http.HttpResponseRedirect(url) else: log.debug("Form errors: %s", form.errors) else: if contact: #If a person has their contact info, make sure we populate it in the form for item in contact.__dict__.keys(): init_data[item] = getattr(contact, item) if contact.shipping_address: for item in contact.shipping_address.__dict__.keys(): init_data["ship_" + item] = getattr( contact.shipping_address, item) if contact.billing_address: for item in contact.billing_address.__dict__.keys(): init_data[item] = getattr(contact.billing_address, item) if contact.primary_phone: init_data['phone'] = contact.primary_phone.phone else: # Allow them to login from this page. request.session.set_test_cookie() init_data['copy_address'] = True form = PaymentContactInfoForm(shop=shop, contact=contact, shippable=tempCart.is_shippable, initial=init_data, cart=tempCart) if shop.in_country_only: only_country = shop.sales_country else: only_country = None context = RequestContext( request, { 'form': form, 'country': only_country, 'paymentmethod_ct': len(form.fields['paymentmethod'].choices) }) return render_to_response('checkout/form.html', context)
from django.conf.urls.defaults import * from satchmo.configuration import config_get_group config = config_get_group('PAYMENT_PAYPAL') urlpatterns = patterns('satchmo', (r'^$', 'payment.modules.paypal.views.pay_ship_info', {'SSL': config.SSL.value}, 'PAYPAL_satchmo_checkout-step2'), (r'^confirm/$', 'payment.modules.paypal.views.confirm_info', {'SSL': config.SSL.value}, 'PAYPAL_satchmo_checkout-step3'), (r'^success/$', 'payment.common.views.checkout.success', {'SSL': config.SSL.value}, 'PAYPAL_satchmo_checkout-success'), )
def pay_ship_info(request): return payship.simple_pay_ship_info(request, config_get_group('PAYMENT_PAYPAL'), 'checkout/paypal/pay_ship.html')