def test_form_render(self):
return_url = 'https://example.com/return_url'
f = PayPalPaymentsForm(initial={'business': '*****@*****.**',
'amount': '10.50',
'shipping': '2.00',
'return_url': return_url,
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
f = PayPalPaymentsForm(initial={'business': '*****@*****.**',
'amount': '10.50',
'shipping': '2.00',
'return': return_url,
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
def test_form_render(self):
return_url = "https://example.com/return_url"
f = PayPalPaymentsForm(
initial={
"business": "*****@*****.**",
"amount": "10.50",
"shipping": "2.00",
"return_url": return_url,
}
)
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn("""buynowCC""", rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
f = PayPalPaymentsForm(
initial={
"business": "*****@*****.**",
"amount": "10.50",
"shipping": "2.00",
"return": return_url,
}
)
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn("""buynowCC""", rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
def test_form_render(self):
return_url = 'https://example.com/return_url'
f = PayPalPaymentsForm(initial={'business': '*****@*****.**',
'amount': '10.50',
'shipping': '2.00',
'return_url': return_url,
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
f = PayPalPaymentsForm(initial={'business': '*****@*****.**',
'amount': '10.50',
'shipping': '2.00',
'return': return_url,
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
self.assertIn('''value="''' + return_url + '''"''', rendered)
def product_detail(request, slug):
'''
It is a smaple funcation that could be used to send only one item to
Paypal. it will send the information of the select product to be paied
in Paypal.
'''
product = get_object_or_404(Product, pk=slug)
paypal = {
'amount': product.price,
'item_name': product.name,
'item_number': product.slug,
# PayPal wants a unique invoice ID
'invoice': str(uuid.uuid1()),
# It'll be a good idea to setup a SITE_DOMAIN inside settings
# so you don't need to hardcode these values.
'return_url': settings.SITE_DOMAIN + 'return_url', #reverse('return_url'),
'cancel_return': settings.SITE_DOMAIN + 'cancel_url', #reverse('cancel_url'),
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
return render_to_response('products/product_detail.html', {
'product' : product,
'form' : rendered_form,
}, RequestContext(request))
def scientist_research_payment_paypal(request, research_id, template='scientist/research_payment_paypal.html',
extra_context=None):
research = get_object_or_404(Research, id=research_id, scientistresearch__scientist=request.user)
# What you want the button to do.
paypal_dict = {
'business': settings.PAYPAL_RECEIVER_EMAIL,
'amount': research.total_credit - request.user.userprofile.available_balance,
'item_name': research.name,
'invoice': '%s-%d' % (research.name, research.id),
'notify_url': '%s%s' % (settings.SITE_NAME, reverse_lazy('paypal-ipn')),
'return_url': '%s%s' % (settings.SITE_NAME, reverse_lazy('research_paypal_complete', args=[research.id, ])),
'cancel_return': 'http://www.example.com/your-cancel-location/',
'custom': research.id,
}
# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict)
if settings.PAYPAL_API_ENVIRONMENT == 'SANDBOX':
paypal_form = form.sandbox()
else:
paypal_form = form.render()
context = {
'form': paypal_form,
'research': research,
}
if extra_context:
context.update(extra_context)
return render_to_response(template, context, context_instance=RequestContext(request))
def paypal_form(request):
domain = Site.objects.get_current().domain
if settings.DEBUG:
domain = "73ee-71-233-245-159.ngrok.io"
paypal_dict = {
"cmd": "_xclick-subscriptions",
"business": "*****@*****.**",
"a3": "12.00", # price
"p3": 1, # duration of each unit (depends on unit)
"t3": "Y", # duration unit ("M for Month")
"src": "1", # make payments recur
"sra": "1", # reattempt payment on payment error
"no_note": "1", # remove extra notes (optional)
"item_name": "NewsBlur Premium Account",
"notify_url": "https://%s%s" % (domain, reverse('paypal-ipn')),
"return_url": "https://%s%s" % (domain, reverse('paypal-return')),
"cancel_return": "https://%s%s" % (domain, reverse('index')),
"custom": request.user.username,
}
# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict, button_type="subscribe")
logging.user(request, "~FBLoading paypal/feedchooser")
# Output the button.
return HttpResponse(form.render(), content_type='text/html')
def checkout(request):
# 订单号
out_trade_no = baseutil.time_hash()
cart = Cart(request)
# 关闭cart购物车,防止付款之前购物车内内容改变
cart.cart.checked_out=True
cart.cart.save()
# 记录transaction
now = datetime.datetime.now()
Transaction.objects.create(out_trade_no=out_trade_no,user=request.user,\
cart=cart.cart,payed_fee=0,trade_time=now)
# What you want the button to do.
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": (cart.total_fee)/5, # exchange rate is 5
"item_name": "Bluessh ssh+vpn fee",
"invoice": out_trade_no, # 本站订单号
"notify_url": "%s%s" % (settings.SITE_URL, '/paypal/ipn_pengzhao/'),
"return_url": "%s/usercenter/" % settings.SITE_URL,
"currency_code":"USD", # 人民币CNY，美元USD
"charset":"utf-8",
}
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
submit_js = "<script>document.forms['paypalsubmit'].submit()</script>"
return render(request,'usercenter/checkout.html',
{'content':paypal_form.render(),'submit_js':submit_js})
def purchase_item(request):
if request.method == "POST":
item_purchase = int(request.POST['item'])
_item = get_object_or_404(item, id=item_purchase)
if _item.user == request.user:
ctx = {'title':'This item belongs to you.','message':'This item belongs to you, you can not buy'}
return render_to_response('message/message.html',ctx,context_instance=RequestContext(request))
frmPurchase = purchases(item=_item,user=request.user)
frmPurchase.save()
paypal = {
'amount':frmPurchase.item.price,
'item_name': frmPurchase.item.title,
'item_number': frmPurchase.item.id,
# PayPal wants a unique invoice ID
'invoice': str(uuid.uuid1()),
# It'll be a good idea to setup a SITE_DOMAIN inside settings
# so you don't need to hardcode these values.
'return_url': settings.SITE_DOMAIN + reverse('return_url'),
'cancel_return': settings.SITE_DOMAIN + reverse('cancel_url'),
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
ctx = {'item' : _item,'form' : rendered_form,}
return render_to_response('store/purchase_thanks.html',ctx,context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/store/')
def pay_item(request,idItem):
idIt = idItem
_item = get_object_or_404(item,id=idIt)
_purch = get_object_or_404(purchases,item=_item)
if _purch.user == request.user:
paypal = {
'amount':_purch.item.price,
'item_name': _purch.item.title,
'item_number': _purch.item.id,
# PayPal wants a unique invoice ID
'invoice': str(uuid.uuid1()),
# It'll be a good idea to setup a SITE_DOMAIN inside settings
# so you don't need to hardcode these values.
'return_url': settings.SITE_DOMAIN + reverse('return_url'),
'cancel_return': settings.SITE_DOMAIN + reverse('cancel_url'),
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
ctx = {'item' : _item,'form' : rendered_form,}
return render_to_response('store/purchase_thanks.html',ctx,context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/profile/purchased/images/')
def paypal_form(order):
# res = {}
paypal = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": order.total(),
"item_name": settings.PAYPAL_SUBJECT_LINE,
#'item_number': 1,
#'quantity':1,
# PayPal wants a unique invoice ID
"invoice": order.uid,
# It'll be a good idea to setup a SITE_DOMAIN inside settings
# so you don't need to hardcode these values.
"currency_code": "EUR",
"lc": "es_ES",
#'notify_url': settings.SITE_DOMAIN + "/tienda/checkout/paypal/ipn",
"notify_url": settings.SITE_DOMAIN + reverse("paypal-ipn"),
"return_url": settings.SITE_DOMAIN + reverse("return_url"),
"cancel_return": settings.SITE_DOMAIN + reverse("cancel_url"),
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
return rendered_form
def checkout(request):
# 订单号
out_trade_no = baseutil.time_hash()
cart = Cart(request)
# 关闭cart购物车,防止付款之前购物车内内容改变
cart.cart.checked_out = True
cart.cart.save()
# 记录transaction
now = datetime.datetime.now()
Transaction.objects.create(out_trade_no=out_trade_no,user=request.user,\
cart=cart.cart,payed_fee=0,trade_time=now)
# What you want the button to do.
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": (cart.total_fee) / 5, # exchange rate is 5
"item_name": "Bluessh ssh+vpn fee",
"invoice": out_trade_no, # 本站订单号
"notify_url": "%s%s" % (settings.SITE_URL, '/paypal/ipn_pengzhao/'),
"return_url": "%s/usercenter/" % settings.SITE_URL,
"currency_code": "USD", # 人民币CNY，美元USD
"charset": "utf-8",
}
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
submit_js = "<script>document.forms['paypalsubmit'].submit()</script>"
return render(request, 'usercenter/checkout.html', {
'content': paypal_form.render(),
'submit_js': submit_js
})
def process(self,request,cart=None):
for k,v in request.REQUEST.iteritems():
if 'product' in k: product = v
elif 'value' in k: value = float(v)
elif 'qty' in k: qty = int(v)
host = 'http://%s' % request.get_host()
paypal = {
'business': settings.PAYPAL_RECEIVER_EMAIL,
'notify_url': '%s%s'%(host,settings.PAYPAL_NOTIFY_URL),
'return_url': '%s%s'%(host,settings.PAYPAL_RETURN_URL),
'cancel_return': '%s%s'%(host,settings.PAYPAL_CANCEL_RETURN),
'currency_code': 'BRL',
}
option = '_cart'; count = 0
form_paypal = PayPalPaymentsForm(initial=paypal)
if cart is not None:
for p in cart:
count += 1
form_paypal.fields['amount_%i'%count] = forms.IntegerField(widget=ValueHiddenInput(),initial=p['value'])
form_paypal.fields['item_name_%i'%count] = forms.CharField(widget=ValueHiddenInput(),initial=p['product'])
form_paypal.fields['quantity_%i'%count] = forms.CharField(widget=ValueHiddenInput(),initial=p['qty'])
else:
form_paypal.fields['amount_1'] = forms.IntegerField(widget=ValueHiddenInput(),initial=value)
form_paypal.fields['item_name_1'] = forms.CharField(widget=ValueHiddenInput(),initial=product)
form_paypal.fields['quantity_1'] = forms.CharField(widget=ValueHiddenInput(),initial=str(qty))
form_paypal.fields['cmd'] = forms.CharField(widget=ValueHiddenInput(),initial=option)
form_paypal.fields['upload'] = forms.CharField(widget=ValueHiddenInput(),initial='1')
return render(request,'form.jade',{'form':form_paypal.render()})
def paypal_form(request):
domain = Site.objects.get_current().domain
paypal_dict = {
"cmd": "_xclick-subscriptions",
"business": "*****@*****.**",
# "business": "*****@*****.**",
"a3": "12.00", # price
"p3": 1, # duration of each unit (depends on unit)
"t3": "Y", # duration unit ("M for Month")
"src": "1", # make payments recur
"sra": "1", # reattempt payment on payment error
"no_note": "1", # remove extra notes (optional)
"item_name": "NewsBlur Premium Account",
"notify_url": "http://%s%s" % (domain, reverse('paypal-ipn')),
"return_url": "http://%s%s" % (domain, reverse('paypal-return')),
"cancel_return": "http://%s%s" % (domain, reverse('index')),
"custom": request.user.username,
}
# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict, button_type="subscribe")
# Output the button.
return HttpResponse(form.render(), mimetype='text/html')
def paypal_form(order):
#res = {}
paypal = {
'business': settings.PAYPAL_RECEIVER_EMAIL,
'amount': order.total(),
'item_name': settings.PAYPAL_SUBJECT_LINE,
#'item_number': 1,
#'quantity':1,
# PayPal wants a unique invoice ID
'invoice': order.uid,
# It'll be a good idea to setup a SITE_DOMAIN inside settings
# so you don't need to hardcode these values.
'currency_code': 'EUR',
'lc': 'es_ES',
#'notify_url': settings.SITE_DOMAIN + "/tienda/checkout/paypal/ipn",
'notify_url': settings.SITE_DOMAIN + reverse('paypal-ipn'),
'return_url': settings.SITE_DOMAIN + reverse('return_url'),
'cancel_return': settings.SITE_DOMAIN + reverse('cancel_url'),
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
return rendered_form
def paypal(request):
# What you want the button to do.
paypal_dict = {
"cmd": "_xclick-subscriptions",
"a1": "0", # trial price
"p1": 1, # trial duration, duration of unit defaults to month
"a3": "1", # yearly price
"p3": 1, # duration of each unit (depends on unit)
"t3": "Y", # duration unit ("M for Month")
"src": "1", # make payments recur
"sra": "1", # reattempt payment on payment error
"no_note": "1", # remove extra notes (optional)
"business": settings.PAYPAL_RECEIVER_EMAIL,
#"amount": "1.00",
"item_name": "one Bondiz",
"invoice": "99",
"notify_url": "%s%s" % (settings.SITE_NAME, reverse('paypal-ipn')),
"return_url": "http://www.bondiz.com/success/",
"cancel_return": "http://www.bondiz.com/cancel/",
}
# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict, button_type="subscribe")
context = {"form": form.render()} # form.render() for real case
return render_to_response("paypal.html", context)
def test_form_render_deprecated_paypal_receiver_email(self):
f = PayPalPaymentsForm(initial={'amount': '10.50',
'shipping': '2.00',
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
def test_form_render_deprecated_paypal_receiver_email(self):
f = PayPalPaymentsForm(initial={'amount': '10.50',
'shipping': '2.00',
})
rendered = f.render()
self.assertIn('''action="https://www.sandbox.paypal.com/cgi-bin/webscr"''', rendered)
self.assertIn('''value="*****@*****.**"''', rendered)
self.assertIn('''value="2.00"''', rendered)
self.assertIn('''value="10.50"''', rendered)
self.assertIn('''buynowCC''', rendered)
def renew_membership(request, club_name):
"""new club memberships and renewals"""
user = request.user
up = user.get_profile()
club = Club.objects.get(safe_name=club_name)
try:
m = Membership.objects.get(user_prof=up, club=club, paid=True)
m.price = club.renew_cost
except Membership.DoesNotExist:
#create new membership
m = Membership()
m.club = club
m.user_prof = up
m.price = club.new_member_cost
m.start = datetime.date.today()
m.valid_thru = m.start + datetime.timedelta(days=365)
#create an order
order = Order()
order.user_prof = up
order.save()
m.order = order
m.save()
redirect_target = request.build_absolute_uri(
reverse('club_detail', kwargs={'club_name': club_name}))
# What you want the button to do.
paypal_dict = {
"business": club.paypal_email,
#'business': '*****@*****.**',
"amount": order.calc_total_price(),
"item_name": 'Membership for %s ' % club.name,
"invoice": order.pk,
"notify_url": request.build_absolute_uri(reverse('paypal-ipn')),
"return_url": redirect_target,
"cancel_return": redirect_target,
}
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
context = {
'paypal_form': paypal_form.render(),
'price': paypal_dict['amount'],
'club': club,
'order': order,
'items': [i.as_leaf_model().cart_name() for i in order.items.all()]
}
return render_to_response('registration/start_pay.html',
context,
context_instance=RequestContext(request))
def render_page(request, order, selectdiscountform=None, claimdiscountform=None, dropforms=None):
context = {}
if float(order.get_full_price()) < 0.01: # Free service. Don't show discount forms. Clear coupons so they are not wasted.
context['show_discounts'] = False
order.reset_discount_claims()
order.save()
else:
context['show_discounts'] = True
# Define forms for managing discounts on order
if not dropforms:
dropforms = [];
for claim in order.get_discount_claims():
dropforms.append({
'label': claim.discount.display_text,
'form': coupons.forms.RemoveDiscountForm(initial={u'discount': claim.pk})
})
context['dropforms'] = dropforms
if not selectdiscountform:
available_claims = order.get_unused_discount_claims()
if available_claims:
selectdiscountform = coupons.forms.SelectDiscountForm(request.user, available_claims=available_claims)
else:
selectdiscountform = None
context['selectdiscountform'] = selectdiscountform
if not claimdiscountform:
claimdiscountform = coupons.forms.ClaimOrSelectDiscountForm(request.user)
context['claimdiscountform'] = claimdiscountform
# Define invoice data
invoice = order.calculate_price()
order.save()
context['invoice'] = invoice
if float(order.get_amount_to_pay()) < 0.01: # No payment due. Free service or 100% covered with discounts
context['paid_service'] = False
return render_to_response("order/submit_payment.html", RequestContext(request, context))
else:
context['paid_service'] = True
# paypal button
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": invoice['amount_due'],
"item_name": order.get_service_description(),
"invoice": order.invoice_id,
"notify_url": "%s%s" % (settings.ROOT_URL, reverse('paypal-ipn')),
"return_url": "%s%s" % (settings.ROOT_URL, 'paymentreceived/'),
"cancel_return": "%s%s" % (settings.ROOT_URL, 'paymentcanceled/'),
}
form = PayPalPaymentsForm(initial=paypal_dict)
if settings.RACK_ENV=='production':
context["pay_button"] = form.render()
else:
context["pay_button"] = form.sandbox()
context["pay_button_message"] = mark_safe(_('Clicking the "Buy Now" button will submit your order and take you away from this site.')+'<br/>'+_('Please complete your secure payment with PayPal.'))
return render_to_response("order/submit_payment.html", RequestContext(request, context))
def get_context_data(self, **kwargs):
context = super(MerchDetailView, self).get_context_data(**kwargs)
merch = context['merch']
paypal = {
'amount': merch.price,
'item_name': merch.title,
'item_number': merch.slug,
'currency_code': 'GBP',
# PayPal wants a unique invoice ID
'invoice': str(uuid.uuid4()),
'return_url': '/merch/thanks',
'cancel_return': merch.get_absolute_url(),
}
form = PayPalPaymentsForm(initial=paypal)
context['form'] = form.sandbox() if settings.DEBUG else form.render()
return context
def paypal_standard(request):
ipn_url = 'http://%s%s' % (Site.objects.get_current().domain, reverse("paypal-ipn"))
pdt_url = 'http://%s%s' % (Site.objects.get_current().domain, reverse("paypal-pdt"))
return_url = pdt_url if config.PDT else ipn_url
data = {
"amount": "1.00",
"item_name": "Samsung Galaxy S3",
"invoice": "INVOICE001",
"notify_url": ipn_url,
"return_url": return_url,
}
form = PayPalPaymentsForm(initial=data)
data['form'] = form.sandbox() if config.DEBUG else form.render()
return render_to_response("payment/paypal/standard.html", data,
context_instance=RequestContext(request))
def carga(request, pago_id):
pago=get_object_or_404(Pagos, pk=pago_id)
usuario_pago=Usuarios_Pagos.objects.get(usuario=request.user, pago=pago)
paypal_dict = {
# "business": settings.PAYPAL_RECEIVER_EMAIL,
"business": pago.correo,
"amount": pago.get_precio,
"item_name": pago.concepto,
"invoice": "pagos_family" + str(pago.id)+"_"+str(request.user.id),
"notify_url": "%s%s" % (SITE_NAME, reverse('paypal-ipn')),
"return_url": "http://joinity.com/",
"cancel_return": "http://joinity.com/",
"custom": usuario_pago.id,
"currency_code": "EUR", # currency
}
form = PayPalPaymentsForm(initial=paypal_dict)
context={"pago":pago, "form":form.render(), "usuario":request.user}
pagina_pago=render_to_string("joinitys/pagos/ajax_ver_pago.html", context)
return simplejson.dumps({"pago":pagina_pago})
def get(self, request):
#order_id = "f66bdb6f83b04b02b70c56d84f9e5b43"
order_id = request.GET.get("order_id")
print("order_id", order_id)
order = get_object_or_404(IconOrder, id=order_id)
#order = IconOrder.objects.create(artist=user, price=50.0)
host = settings.SITE_URL
paypal_dict = {
'business': settings.PAYPAL_RECEIVER_EMAIL,
'amount': '%.2f' % order.price,
'item_name': f"Order {order.id}",
'invoice': str(order.id),
'currency_code': 'USD',
#'notify_url': f"http://{host}{reverse('paypal-ipn')}",
'return_url': f"{host}/payment/paypal/done",
#'cancel_return': f"http://{host}{reverse('payment_cancelled')}",
}
form = PayPalPaymentsForm(initial=paypal_dict)
return Response({"form": form.render()})
"""
def paypal(request, treatment_id):
# What you want the button to do.
try:
treatment = Treatment.objects.get(id=treatment_id)
except:
raise Http404
treatment_price = system.GET_TREATMENT_PRICE()
treatment_time = system.GET_TREATMENT_TIME_LIMIT()
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"charset": "utf-8",
"amount": "%s" % treatment_price,
"item_name": u"Avaliação e Orientação Dermatológica",
"custom": treatment_id,
"invoice": treatment_id,
"notify_url": "%s%s" % (settings.SITE_NAME, reverse('paypal-ipn')),
"return_url": "%s%s" % (settings.SITE_NAME, reverse('paypalreturn')),
"cancel_return": "%s%s" % (settings.SITE_NAME, reverse('paypal-cancel-return')),
}
# Create the instance.
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
free_treatments = system.GET_FREE_TREATMENTS()
if settings.PAYPAL_TEST:
paypal_form = paypal_form.sandbox()
else:
paypal_form = paypal_form.render()
context = {"paypal_form": paypal_form, "treatment": treatment, "treatment_time": treatment_time, "free_treatments": free_treatments}
return render_to_response("treatments/checkout.html", context, context_instance=RequestContext(request))
from paypal.pro.views import PayPalPro
def event_register(request, club_name, season_year, event_name, username=None):
"""register for an event"""
up = request.user.get_profile()
e = Event.objects.select_related('season', 'season__club', 'user_profile').\
get(season__club__safe_name=club_name,
season__year=season_year,
safe_name=event_name)
redirect_target = reverse('registration.views.event',
args=[club_name, season_year, event_name])
form_template = 'registration/event_reg_form.html'
reg = None
if username:
reg = e.regs.get(user_profile__user__username=username)
show_cars = bool(
Car.objects.filter(user_profile=up, provisional=False).count())
class UserRegForm(
RegForm
): #have to create the form here, since it's specific to a user
car = CarChoiceField(queryset=Car.objects.filter(user_profile=up,
provisional=False),
required=False,
empty_label=None)
event = ModelChoiceField(queryset=Event.objects.filter(pk=e.pk),
initial=e.pk,
widget=HiddenInput())
club = ModelChoiceField(queryset=Club.objects.filter(pk=e.club.pk),
initial=e.club.pk,
widget=HiddenInput())
user_profile = ModelChoiceField(
queryset=UserProfile.objects.filter(pk=up.pk),
initial=up.pk,
widget=HiddenInput())
def __init__(self, *args, **kwargs):
super(UserRegForm, self).__init__(*args, **kwargs)
if not show_cars:
self.fields['car'].widget = HiddenInput()
if reg and reg.paid: #hide reg if paid
self.fields['prepay'].widget = HiddenInput()
self.fields['coupon_code'].widget = HiddenInput()
if request.method == 'POST':
form = UserRegForm(request.POST,
request.FILES,
user=request.user,
instance=reg)
if form.is_valid():
reg = form.save()
if form.cleaned_data['prepay']:
#figure out base reg price (member or not?)
member = up.is_member(e.club)
if member:
reg.price = e.member_price
else:
reg.price = e.non_member_price
up = request.user.get_profile()
#construct order, add reg to order
order = Order()
order.user_prof = up
if form.coupon:
order.coupon = form.coupon
order.coupon.uses_left -= 1
order.save()
reg.order = order
reg.save()
# What you want the button to do.
paypal_dict = {
"business": e.club.paypal_email,
#'business': '*****@*****.**',
"amount": order.calc_total_price(),
"item_name":
'Registration for %s %s' % (e.club.name, e.name),
"invoice": order.pk,
"notify_url":
request.build_absolute_uri(reverse('paypal-ipn')),
"return_url": request.build_absolute_uri(redirect_target),
"cancel_return":
request.build_absolute_uri(redirect_target),
}
if paypal_dict[
'amount'] == '0.00': #don't need to pay if the price is 0
order.payment_complete()
return HttpResponseRedirect(redirect_target)
else:
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
context = {
'paypal_form':
paypal_form.render(),
'price':
paypal_dict['amount'],
'club':
e.club,
'order':
order,
'items': [
i.as_leaf_model().cart_name()
for i in order.items.all()
]
}
return render_to_response(
'registration/start_pay.html',
context,
context_instance=RequestContext(request))
return HttpResponseRedirect(redirect_target)
else:
form = UserRegForm(instance=reg)
context = {
'event': e,
'season': e.season,
'club': e.club,
'form': form,
}
return render_to_response(form_template,
context,
context_instance=RequestContext(request))
def donate(request, p, engine):
if not can_accept_donations(p):
return redirect("project-main", project_id=p.id)
is_test_donation = getattr(settings, "DONATION_TEST", False)
if request.method == "POST":
donate_form = InvoiceForm(data=request.POST, project=p, engine=engine)
if donate_form.is_valid():
description = u"Akvo-%d-%s" % (p.id, p.title)
cd = donate_form.cleaned_data
invoice = donate_form.save(commit=False)
invoice.project = p
invoice.engine = engine
invoice.name = cd["name"]
invoice.email = cd["email"]
invoice.campaign_code = cd["campaign_code"]
invoice.is_anonymous = not cd["is_public"]
original_http_referer = request.session.get(
"original_http_referer", None)
if original_http_referer:
invoice.http_referer = original_http_referer
del request.session["original_http_referer"]
else:
invoice.http_referer = request.META.get("HTTP_REFERER", None)
if is_test_donation:
invoice.test = True
if request.session.get("donation_return_url", False):
return_url = urljoin(request.session["donation_return_url"],
reverse("donate_thanks"))
else:
return_url = urljoin(request.META['HTTP_ORIGIN'],
reverse("donate_thanks"))
if engine == "ideal":
invoice.bank = cd["bank"]
mollie_dict = dict(amount=invoice.amount * 100,
bank_id=invoice.bank,
partnerid=invoice.gateway,
description=description,
reporturl=urljoin(
request.META['HTTP_ORIGIN'],
reverse("mollie_report")),
returnurl=return_url)
try:
mollie_response = query_mollie(mollie_dict, "fetch")
invoice.transaction_id = mollie_response["transaction_id"]
order_url = mollie_response["order_url"]
invoice.save()
except:
return redirect("donate_500")
return render_to_response(
"donate/donate_step3.html",
dict(invoice=invoice,
project=p,
payment_engine=engine,
mollie_order_url=order_url),
context_instance=RequestContext(request))
elif engine == "paypal":
invoice.save()
pp_dict = dict(cmd="_donations",
currency_code=invoice.currency,
business=invoice.gateway,
amount=invoice.amount,
item_name=description,
invoice=int(invoice.id),
lc=invoice.locale,
notify_url=urljoin(request.META['HTTP_ORIGIN'],
reverse("paypal_ipn")),
return_url=return_url,
cancel_url=request.META['HTTP_ORIGIN'])
pp_form = PayPalPaymentsForm(initial=pp_dict)
if is_test_donation:
pp_button = pp_form.sandbox()
else:
pp_button = pp_form.render()
return render_to_response(
"donate/donate_step3.html",
dict(invoice=invoice,
payment_engine=engine,
pp_form=pp_form,
pp_button=pp_button,
project=p),
context_instance=RequestContext(request))
else:
invoice_id = request.GET.get("invoice_id", None)
if not invoice_id:
donate_form = InvoiceForm(project=p,
engine=engine,
initial=dict(is_public=True))
else:
invoice = get_object_or_404(Invoice, pk=invoice_id)
donate_form = InvoiceForm(project=p,
engine=engine,
initial=dict(
amount=invoice.amount,
name=invoice.name,
email=invoice.email,
email2=invoice.email,
campaign_code=invoice.campaign_code,
is_public=not invoice.is_anonymous))
if request.session.get("donation_return_url", False):
request.session["cancel_url"] = urljoin(
request.session["donation_return_url"],
reverse("project-main", kwargs={'project_id': p.id}))
else:
request.session["cancel_url"] = reverse(
"project-main", kwargs={'project_id': p.id})
return render_to_response("donate/donate_step2.html",
dict(donate_form=donate_form,
payment_engine=engine,
project=p),
context_instance=RequestContext(request))
def donate(request, p, engine):
if not can_accept_donations(p):
return redirect("project-main", project_id=p.id)
is_test_donation = getattr(settings, "DONATION_TEST", False)
if request.method == "POST":
donate_form = InvoiceForm(data=request.POST, project=p, engine=engine)
if donate_form.is_valid():
description = u"Akvo-%d-%s" % (p.id, p.title)
cd = donate_form.cleaned_data
invoice = donate_form.save(commit=False)
invoice.project = p
invoice.engine = engine
invoice.name = cd["name"]
invoice.email = cd["email"]
invoice.campaign_code = cd["campaign_code"]
invoice.is_anonymous = not cd["is_public"]
original_http_referer = request.session.get("original_http_referer", None)
if original_http_referer:
invoice.http_referer = original_http_referer
del request.session["original_http_referer"]
else:
invoice.http_referer = request.META.get("HTTP_REFERER", None)
if is_test_donation:
invoice.test = True
if request.session.get("donation_return_url", False):
return_url = urljoin(request.session["donation_return_url"],
reverse("donate_thanks"))
else:
return_url = urljoin(request.META['HTTP_ORIGIN'], reverse("donate_thanks"))
if engine == "ideal":
invoice.bank = cd["bank"]
mollie_dict = dict(
amount=invoice.amount * 100,
bank_id=invoice.bank,
partnerid=invoice.gateway,
description=description,
reporturl=urljoin(request.META['HTTP_ORIGIN'], reverse("mollie_report")),
returnurl=return_url)
try:
mollie_response = query_mollie(mollie_dict, "fetch")
invoice.transaction_id = mollie_response["transaction_id"]
order_url = mollie_response["order_url"]
invoice.save()
except:
return redirect("donate_500")
return render_to_response("donate/donate_step3.html",
dict(invoice=invoice,
project=p,
payment_engine=engine,
mollie_order_url=order_url),
context_instance=RequestContext(request))
elif engine == "paypal":
invoice.save()
pp_dict = dict(
cmd="_donations",
currency_code=invoice.currency,
business=invoice.gateway,
amount=invoice.amount,
item_name=description,
invoice=int(invoice.id),
lc=invoice.locale,
notify_url=urljoin(request.META['HTTP_ORIGIN'], reverse("paypal_ipn")),
return_url=return_url,
cancel_url=request.META['HTTP_ORIGIN'])
pp_form = PayPalPaymentsForm(initial=pp_dict)
if is_test_donation:
pp_button = pp_form.sandbox()
else:
pp_button = pp_form.render()
return render_to_response("donate/donate_step3.html",
dict(invoice=invoice,
payment_engine=engine,
pp_form=pp_form,
pp_button=pp_button,
project=p),
context_instance=RequestContext(request))
else:
invoice_id = request.GET.get("invoice_id", None)
if not invoice_id:
donate_form = InvoiceForm(project=p,
engine=engine,
initial=dict(is_public=True))
else:
invoice = get_object_or_404(Invoice, pk=invoice_id)
donate_form = InvoiceForm(project=p,
engine=engine,
initial=dict(amount=invoice.amount,
name=invoice.name,
email=invoice.email,
email2=invoice.email,
campaign_code=invoice.campaign_code,
is_public=not invoice.is_anonymous))
if request.session.get("donation_return_url", False):
request.session["cancel_url"] = urljoin(request.session["donation_return_url"],
reverse("project-main",
kwargs={'project_id': p.id}))
else:
request.session["cancel_url"] = reverse("project-main", kwargs={'project_id': p.id})
return render_to_response("donate/donate_step2.html",
dict(donate_form=donate_form,
payment_engine=engine,
project=p),
context_instance=RequestContext(request))
def render_page(request,
order,
selectdiscountform=None,
claimdiscountform=None,
dropforms=None):
context = {}
if float(
order.get_full_price()
) < 0.01: # Free service. Don't show discount forms. Clear coupons so they are not wasted.
context['show_discounts'] = False
order.reset_discount_claims()
order.save()
else:
context['show_discounts'] = True
# Define forms for managing discounts on order
if not dropforms:
dropforms = []
for claim in order.get_discount_claims():
dropforms.append({
'label':
claim.discount.display_text,
'form':
coupons.forms.RemoveDiscountForm(
initial={u'discount': claim.pk})
})
context['dropforms'] = dropforms
if not selectdiscountform:
available_claims = order.get_unused_discount_claims()
if available_claims:
selectdiscountform = coupons.forms.SelectDiscountForm(
request.user, available_claims=available_claims)
else:
selectdiscountform = None
context['selectdiscountform'] = selectdiscountform
if not claimdiscountform:
claimdiscountform = coupons.forms.ClaimOrSelectDiscountForm(
request.user)
context['claimdiscountform'] = claimdiscountform
# Define invoice data
invoice = order.calculate_price()
order.save()
context['invoice'] = invoice
if float(
order.get_amount_to_pay()
) < 0.01: # No payment due. Free service or 100% covered with discounts
context['paid_service'] = False
return render_to_response("order/submit_payment.html",
RequestContext(request, context))
else:
context['paid_service'] = True
# paypal button
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": invoice['amount_due'],
"item_name": order.get_service_description(),
"invoice": order.invoice_id,
"notify_url":
"%s%s" % (settings.ROOT_URL, reverse('paypal-ipn')),
"return_url": "%s%s" % (settings.ROOT_URL, 'paymentreceived/'),
"cancel_return":
"%s%s" % (settings.ROOT_URL, 'paymentcanceled/'),
}
form = PayPalPaymentsForm(initial=paypal_dict)
if settings.RACK_ENV == 'production':
context["pay_button"] = form.render()
else:
context["pay_button"] = form.sandbox()
context["pay_button_message"] = mark_safe(
_('Clicking the "Buy Now" button will submit your order and take you away from this site.'
) + '<br/>' +
_('Please complete your secure payment with PayPal.'))
return render_to_response("order/submit_payment.html",
RequestContext(request, context))
def processcheckout(request):
"""
Paypal checkout
"""
from django.conf import settings
from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed
from pages.models import Page, Bill
if request.method == "POST" and request.is_ajax():
page = getPage(request)
####GET THE KEYS
try:
charges = request.POST["charges"]
domainname = request.POST["domainname"]
domainoption = request.POST["domainoption"]
except:
return HttpResponseBadRequest(u"%s" % _("an error occured when processing checkout"))
if charges == "yearly": ###########################CHECK CONFORMITY OF CHARGES
item_name = _("EldonPage suscribtion for 1 year")
amount = settings.PAGE_MONTHLY_PRICE * 12
t3 = "Y"
p3 = 1
elif charges == "sixmonth":
item_name = _("EldonPage suscribtion for six month")
amount = settings.PAGE_MONTHLY_PRICE * 6
t3 = "M"
p3 = 6
elif charges == "monthly":
item_name = _("EldonPage suscribtion for 1 monthly")
amount = settings.PAGE_MONTHLY_PRICE
t3 = "M"
p3 = 1
else:
return HttpResponseBadRequest(u"%s" % _("an error occured when processing checkout"))
import uuid ###########################CREATE THE BILL
invoice = str(uuid.uuid1())
#### WE CHECK FIRST IF USER HAS ALREADY CREATED A BILL
try:
bill = Bill.objects.get(page=page, invoice_type="creation")
bill.amount = amount
bill.invoice = invoice
bill.domain = domainname
bill.save()
except Bill.DoesNotExist:
bill = Bill(page=page, amount=amount, invoice=invoice, domain=domainname)
bill.save()
except:
return HttpResponse(u"%s" % _("an error occured when processing checkout"))
from paypal.standard.forms import PayPalPaymentsForm
paypal = {
"business": settings.PAYPAL_RECEIVER_EMAIL, # settings.PAYPAL_RECEIVER_EMAIL,
"item_name": item_name,
"currency_code": "USD",
"a3": amount, # monthly price
"p3": p3, # duration of each unit (depends on unit)
"t3": t3, # duration unit ("M for Month")
"src": "1", # make payments recur
"sra": "1", # reattempt payment on payment error
"no_note": "1", # remove extra notes (optional)
"invoice": invoice,
"cmd": "_xclick-subscriptions",
"custom": page.id,
"notify_url": "http://eldonpage.com/sdf5f2sf/sdf56sfd/sfsf6s3/sdfd3r23rs/csdc65/32w3cds/",
"return_url": "http://eldonpage.com/editpage/",
"cancel_return": "http://eldonpage.com/editpage/",
}
form = PayPalPaymentsForm(initial=paypal)
if settings.DEBUG:
rendered_form = form.sandbox()
else:
rendered_form = form.render()
return HttpResponse(rendered_form)
return HttpResponseBadRequest(u"%s" % _("an error occured when processing checkout"))
def test_form_endpont(self):
with self.settings(PAYPAL_TEST=False):
f = PayPalPaymentsForm(initial={})
self.assertNotIn('sandbox', f.render())
def test_form_endpont(self):
with self.settings(PAYPAL_TEST=False):
f = PayPalPaymentsForm(initial={})
self.assertNotIn('sandbox', f.render())
def register(request):
#XXX: close registration
#return HttpResponseRedirect('/register/closed/')
#Make sure user didn't already register
try:
status = Order.objects.filter(user=request.user, year=2013)[0]
return HttpResponseRedirect('/order/')
except:
pass
#Get the list of dropoffpickuptimes
dp_qset = DropoffPickupTime.objects.filter(year=2013).extra(order_by= ['slot_id'])
tmp = [str(x).split(', ') for x in dp_qset]
dp_times = [(str(x.id),
y[0],
y[1],
y[2],
x.n_boxes_total-x.n_boxes_bought) for x,y in zip(dp_qset,tmp)]
#Process the user's input if POST
if request.method == 'POST':
reg_form = RegistrationForm(request.POST)
if not reg_form.is_valid():
try: c = request.POST['dropoff_pickup_time']
except: c = None
return render_to_response('storage/register_1_info.html',
{'reg_form': reg_form,
'box_price': reg_form.BOX_PRICE,
'max_boxes': reg_form.MAX_BOXES,
'dp_choice': c,
'dp_times': dp_times},
RequestContext(request))
form = reg_form.save(request.user, commit=True)
#Render data to show on next page
unpaid_order = UnpaidOrder.objects.get(invoice_id=form.invoice_id)
reg_info = ((0, 'NetID:', request.user.username),
(0, 'Email:', request.user.username+'@princeton.edu'),
(0, 'Cell phone number*:', unpaid_order.cell_number),
(1, 'Dropoff/pickup time*:', str(unpaid_order.dropoff_pickup_time).split(', ')),
(0, 'Price per box:', '$'+reg_form.BOX_PRICE),
(0, 'Quantity (max %d)*:'%reg_form.MAX_BOXES, unpaid_order.n_boxes_bought),
(0, 'Total price:', '$%.2f'%(float(reg_form.BOX_PRICE)*unpaid_order.n_boxes_bought)),
(0, ' ', ' '),
(0, 'Proxy name:', unpaid_order.proxy_name),
(0, 'Proxy email:', unpaid_order.proxy_email))
# Considers boxes bought before paypal goes through.
# NEED SCRIPT TO MAKE SURE THAT THIS ORDER WENT THROUGH
dropoff_pickup_time = unpaid_order.dropoff_pickup_time
dropoff_pickup_time.n_boxes_bought += unpaid_order.n_boxes_bought
dropoff_pickup_time.save()
pp_details = {
'business': '*****@*****.**',
#'business': '*****@*****.**',
'item_name': "USG summer storage boxes",
'item_number': "box",
'amount': reg_form.BOX_PRICE,
'quantity': unpaid_order.n_boxes_bought,
'invoice': unpaid_order.invoice_id,
'notify_url': settings.SITE_DOMAIN+'/paypal/ipntesturl123/',
'test_ipn':1,
'return_url': settings.SITE_DOMAIN+'/register/complete/',
'cancel_return': settings.SITE_DOMAIN+'/register/',
}
pp_form = PayPalPaymentsForm(initial=pp_details)
#pp_form_rendered = pp_form.sandbox()
pp_form_rendered = pp_form.render()
return render_to_response('storage/register_2_paypal.html',
{'reg_info': reg_info,
'pp_info': pp_form_rendered},
RequestContext(request))
#Return empty form if GET
reg_form = RegistrationForm()
return render_to_response('storage/register_1_info.html',
{'reg_form': reg_form,
'box_price': reg_form.BOX_PRICE,
'max_boxes': reg_form.MAX_BOXES,
'dp_times': dp_times},
RequestContext(request))
def donate(request, p, engine, has_sponsor_banner=False):
if p not in Project.objects.published().need_funding():
return redirect("project_main", project_id=p.id)
if get_object_or_404(Organisation, pk=settings.LIVE_EARTH_ID) in p.sponsor_partners():
has_sponsor_banner = True
if request.method == "POST":
donate_form = InvoiceForm(data=request.POST, user=request.user, project=p, engine=engine)
if donate_form.is_valid():
cd = donate_form.cleaned_data
invoice = donate_form.save(commit=False)
invoice.project = p
invoice.engine = engine
if request.user.is_authenticated() and request.user.email:
invoice.user = request.user
else:
invoice.name = cd["name"]
invoice.email = cd["email"]
original_http_referer = request.session.get("original_http_referer", None)
if original_http_referer:
invoice.http_referer = original_http_referer
del request.session["original_http_referer"]
else:
invoice.http_referer = request.META.get("HTTP_REFERER", None)
if settings.DONATION_TEST:
invoice.test = True
if engine == "ideal":
invoice.bank = cd["bank"]
mollie_dict = {
"amount": invoice.amount * 100,
"bank_id": invoice.bank,
"partnerid": invoice.gateway,
"description": u"Donation: Akvo Project %d" % int(p.id),
"reporturl": settings.MOLLIE_REPORT_URL,
"returnurl": settings.MOLLIE_RETURN_URL,
}
try:
mollie_response = query_mollie(mollie_dict, "fetch")
invoice.transaction_id = mollie_response["transaction_id"]
order_url = mollie_response["order_url"]
invoice.save()
except:
return redirect("donate_500")
return render_to_response(
"rsr/donate_step3.html",
{
"invoice": invoice,
"p": p,
"payment_engine": engine,
"mollie_order_url": order_url,
"has_sponsor_banner": has_sponsor_banner,
"live_earth_enabled": settings.LIVE_EARTH_ENABLED,
},
context_instance=RequestContext(request),
)
elif engine == "paypal":
invoice.save()
pp_dict = {
"cmd": getattr(settings, "PAYPAL_COMMAND", "_donations"),
"currency_code": invoice.currency,
"business": invoice.gateway,
"amount": invoice.amount,
"item_name": u"%s: Project %d - %s"
% (settings.PAYPAL_PRODUCT_DESCRIPTION_PREFIX, int(invoice.project.id), invoice.project.name),
"invoice": int(invoice.id),
"lc": invoice.locale,
"notify_url": settings.PAYPAL_NOTIFY_URL,
"return_url": settings.PAYPAL_RETURN_URL,
"cancel_url": settings.PAYPAL_CANCEL_URL,
}
pp_form = PayPalPaymentsForm(initial=pp_dict)
if settings.PAYPAL_TEST:
pp_button = pp_form.sandbox()
else:
pp_button = pp_form.render()
action = request.POST.get("action", None)
return render_to_response(
"rsr/donate_step3.html",
{
"invoice": invoice,
"payment_engine": engine,
"pp_form": pp_form,
"pp_button": pp_button,
"p": p,
"has_sponsor_banner": has_sponsor_banner,
"live_earth_enabled": settings.LIVE_EARTH_ENABLED,
},
context_instance=RequestContext(request),
)
else:
donate_form = InvoiceForm(user=request.user, project=p, engine=engine)
return render_to_response(
"rsr/donate_step2.html",
{
"donate_form": donate_form,
"payment_engine": engine,
"p": p,
"has_sponsor_banner": has_sponsor_banner,
"live_earth_enabled": settings.LIVE_EARTH_ENABLED,
},
context_instance=RequestContext(request),
)
def donate(request, p, engine, has_sponsor_banner=False):
if p not in Project.objects.published().need_funding():
return redirect('project_main', project_id=p.id)
if get_object_or_404(Organisation, pk=settings.LIVE_EARTH_ID) in p.sponsor_partners():
has_sponsor_banner = True
if request.method == 'POST':
donate_form = InvoiceForm(data=request.POST, project=p, engine=engine)
if donate_form.is_valid():
cd = donate_form.cleaned_data
invoice = donate_form.save(commit=False)
invoice.project = p
invoice.engine = engine
invoice.name = cd['name']
invoice.email = cd['email']
original_http_referer = request.session.get('original_http_referer', None)
if original_http_referer:
invoice.http_referer = original_http_referer
del request.session['original_http_referer']
else:
invoice.http_referer = request.META.get('HTTP_REFERER', None)
if settings.DONATION_TEST:
invoice.test = True
if engine == 'ideal':
invoice.bank = cd['bank']
mollie_dict = {
'amount': invoice.amount * 100,
'bank_id': invoice.bank,
'partnerid': invoice.gateway,
'description': u'Donation: Akvo Project %d' % int(p.id),
'reporturl': settings.MOLLIE_REPORT_URL,
'returnurl': settings.MOLLIE_RETURN_URL}
try:
mollie_response = query_mollie(mollie_dict, 'fetch')
invoice.transaction_id = mollie_response['transaction_id']
order_url = mollie_response['order_url']
invoice.save()
except:
return redirect('donate_500')
return render_to_response('rsr/donate_step3.html',
{'invoice': invoice,
'p': p,
'payment_engine': engine,
'mollie_order_url': order_url,
'has_sponsor_banner': has_sponsor_banner,
'live_earth_enabled': settings.LIVE_EARTH_ENABLED},
context_instance=RequestContext(request))
elif engine == 'paypal':
invoice.save()
pp_dict = {
'cmd': getattr(settings, 'PAYPAL_COMMAND', '_donations'),
'currency_code': invoice.currency,
'business': invoice.gateway,
'amount': invoice.amount,
'item_name': u'%s: Project %d - %s' % (settings.PAYPAL_PRODUCT_DESCRIPTION_PREFIX,
int(invoice.project.id), invoice.project.name),
'invoice': int(invoice.id),
'lc': invoice.locale,
'notify_url': settings.PAYPAL_NOTIFY_URL,
'return_url': settings.PAYPAL_RETURN_URL,
'cancel_url': settings.PAYPAL_CANCEL_URL}
pp_form = PayPalPaymentsForm(initial=pp_dict)
if settings.PAYPAL_TEST:
pp_button = pp_form.sandbox()
else:
pp_button = pp_form.render()
action = request.POST.get('action', None)
return render_to_response('rsr/donate_step3.html',
{'invoice': invoice,
'payment_engine': engine,
'pp_form': pp_form,
'pp_button': pp_button,
'p': p,
'has_sponsor_banner': has_sponsor_banner,
'live_earth_enabled': settings.LIVE_EARTH_ENABLED},
context_instance=RequestContext(request))
else:
donate_form = InvoiceForm(project=p, engine=engine)
return render_to_response('rsr/donate_step2.html',
{'donate_form': donate_form,
'payment_engine': engine,
'p': p,
'has_sponsor_banner': has_sponsor_banner,
'live_earth_enabled': settings.LIVE_EARTH_ENABLED},
context_instance=RequestContext(request))
def register(request):
#XXX: close registration
return HttpResponseRedirect('/register/closed/')
#Make sure user didn't already register
try:
status = Order.objects.get(user=request.user)
return HttpResponseRedirect('/order/')
except:
pass
#Get the list of dropoffpickuptimes
dp_qset = DropoffPickupTime.objects.all()
tmp = [str(x).split(', ') for x in dp_qset]
dp_times = [(str(x.id),
y[0],
y[1],
y[2],
x.n_boxes_total-x.n_boxes_bought) for x,y in zip(dp_qset,tmp)]
#Process the user's input if POST
if request.method == 'POST':
reg_form = RegistrationForm(request.POST)
if not reg_form.is_valid():
try: c = request.POST['dropoff_pickup_time']
except: c = None
return render_to_response('storage/register_1_info.html',
{'reg_form': reg_form,
'box_price': reg_form.BOX_PRICE,
'max_boxes': reg_form.MAX_BOXES,
'dp_choice': c,
'dp_times': dp_times},
RequestContext(request))
form = reg_form.save(request.user, commit=True)
#Render data to show on next page
unpaid_order = UnpaidOrder.objects.get(invoice_id=form.invoice_id)
reg_info = ((0, 'NetID:', request.user.username),
(0, 'Email:', request.user.username+'@princeton.edu'),
(0, 'Cell phone number*:', unpaid_order.cell_number),
(1, 'Dropoff/pickup time*:', str(unpaid_order.dropoff_pickup_time).split(', ')),
(0, 'Price per box:', '$'+reg_form.BOX_PRICE),
(0, 'Quantity (max %d)*:'%reg_form.MAX_BOXES, unpaid_order.n_boxes_bought),
(0, 'Total price:', '$%.2f'%(float(reg_form.BOX_PRICE)*unpaid_order.n_boxes_bought)),
(0, ' ', ' '),
(0, 'Proxy name:', unpaid_order.proxy_name),
(0, 'Proxy email:', unpaid_order.proxy_email))
pp_details = {
'business': '*****@*****.**',
#'business': '*****@*****.**',
'item_name': "USG summer storage boxes",
'item_number': "box",
'amount': reg_form.BOX_PRICE,
'quantity': unpaid_order.n_boxes_bought,
'invoice': unpaid_order.invoice_id,
'notify_url': settings.SITE_DOMAIN+'/paypal/ipntesturl123/',
'return_url': settings.SITE_DOMAIN+'/register/complete/',
'cancel_return': settings.SITE_DOMAIN+'/register/',
}
pp_form = PayPalPaymentsForm(initial=pp_details)
#pp_form_rendered = pp_form.sandbox()
pp_form_rendered = pp_form.render()
return render_to_response('storage/register_2_paypal.html',
{'reg_info': reg_info,
'pp_info': pp_form_rendered},
RequestContext(request))
#Return empty form if GET
reg_form = RegistrationForm()
return render_to_response('storage/register_1_info.html',
{'reg_form': reg_form,
'box_price': reg_form.BOX_PRICE,
'max_boxes': reg_form.MAX_BOXES,
'dp_times': dp_times},
RequestContext(request))
