def redirect_to_express(self):
"""
First step of ExpressCheckout. Redirect the request to PayPal using the
data returned from setExpressCheckout.
"""
wpp = PayPalWPP(self.request)
try:
nvp_obj = wpp.setExpressCheckout(self.item)
except PayPalFailure:
log.exception('paypal failure')
self.context['errors'] = self.errors['paypal']
return self.render_payment_form()
else:
pp_params = dict(
token=nvp_obj.token,
L_PAYMENTREQUEST_0_AMTm=self.item['PAYMENTREQUEST_0_AMT'],
PAYMENTREQUEST_0_ITEMAMT=self.item['PAYMENTREQUEST_0_AMT'],
PAYMENTREQUEST_0_AMT=self.item['PAYMENTREQUEST_0_AMT'],
PAYMENTREQUEST_0_DESC=self.item['PAYMENTREQUEST_0_DESC'],
PAYMENTREQUEST_0_CURRENCYCODE=self.
item['PAYMENTREQUEST_0_CURRENCYCODE'],
RETURNURL=self.item['returnurl'],
CANCELURL=self.item['cancelurl'])
pp_url = self.get_endpoint() % urlencode(pp_params)
# log.info('redirect data: %s'% pp_url)
return HttpResponseRedirect(pp_url)
def recurring(self, money, creditcard, options={}):
# raise NotImplementedError
params = {}
params['profilestartdate'] = options.get(
'startdate') or datetime.datetime.now().strftime(
"%Y-%m-%dT00:00:00Z")
params['startdate'] = options.get(
'startdate') or datetime.datetime.now().strftime("%m%Y")
params['billingperiod'] = options.get('billingperiod') or 'Month'
params['billingfrequency'] = options.get('billingfrequency') or '1'
params['amt'] = money
params['desc'] = 'description of the billing'
params['creditcardtype'] = creditcard.card_type.card_name
params['acct'] = creditcard.number
params['expdate'] = '%02d%04d' % (creditcard.month, creditcard.year)
params['firstname'] = creditcard.first_name
params['lastname'] = creditcard.last_name
wpp = PayPalWPP(options.get('request', {}))
try:
response = wpp.createRecurringPaymentsProfile(params, direct=True)
transaction_was_successful.send(sender=self,
type="purchase",
response=response)
except PayPalFailure, e:
transaction_was_unsuccessful.send(sender=self,
type="purchase",
response=e)
# Slight skewness because of the way django-paypal
# is implemented.
return {"status": "FAILURE", "response": e}
def process(self, request, item):
"""Process a PayPal direct payment."""
from paypal.pro.helpers import PayPalWPP
wpp = PayPalWPP(request)
params = self.cleaned_data
params['creditcardtype'] = self.fields['acct'].card_type
params['expdate'] = self.cleaned_data['expdate'].strftime("%m%Y")
try:
params['ipaddress'] = request.META["REMOTE_ADDR"]
except KeyError:
params['ipaddress'] = request.META.get("HTTP_X_FORWARDED_FOR",
"0:0:0:0:0:0")
params.update(item)
try:
# Create single payment:
if 'billingperiod' not in params:
nvp_obj = wpp.doDirectPayment(params)
# Create recurring payment:
else:
nvp_obj = wpp.createRecurringPaymentsProfile(params,
direct=True)
except PayPalFailure:
return False
return True
def paypal_start(request):
"""
Creating express checkout request from users cart
"""
try:
params = get_cart_data_from_request(request)
host_name = request.get_host()
params.update({
"returnurl": "http://" + host_name + "/order/paypal/confirm",
"cancelurl": "http://" + host_name + "/#!/cart",
"noshipping": 2,
})
wpp = PayPalWPP()
nvp = wpp.setExpressCheckout(params)
response = HttpResponseRedirect(
settings.PAYPAL_URL +
'/cgi-bin/webscr?cmd=_express-checkout&token=' + nvp.token)
response.delete_cookie('cart')
return response
except Exception, e:
#log error here
print e
return HttpResponseRedirect("/#!/cart")
def purchase(self, money, credit_card, options=None):
"""Using PAYPAL DoDirectPayment, charge the given
credit card for specified money"""
if not options:
options = {}
if not self.validate_card(credit_card):
raise InvalidCard("Invalid Card")
params = {}
params['creditcardtype'] = credit_card.card_type.card_name
params['acct'] = credit_card.number
params['expdate'] = '%02d%04d' % (credit_card.month, credit_card.year)
params['cvv2'] = credit_card.verification_value
params['ipaddress'] = options['request'].META.get("REMOTE_ADDR", "")
params['amt'] = money
if options.get("email"):
params['email'] = options["email"]
address = options.get("billing_address", {})
first_name = None
last_name = None
try:
first_name, last_name = address.get("name", "").split(" ")
except ValueError:
pass
params['firstname'] = first_name or credit_card.first_name
params['lastname'] = last_name or credit_card.last_name
params['street'] = address.get("address1", '')
params['street2'] = address.get("address2", "")
params['city'] = address.get("city", '')
params['state'] = address.get("state", '')
params['countrycode'] = address.get("country", '')
params['zip'] = address.get("zip", '')
params['phone'] = address.get("phone", "")
shipping_address = options.get("shipping_address", None)
if shipping_address:
params['shiptoname'] = shipping_address["name"]
params['shiptostreet'] = shipping_address["address1"]
params['shiptostreet2'] = shipping_address.get("address2", "")
params['shiptocity'] = shipping_address["city"]
params['shiptostate'] = shipping_address["state"]
params['shiptocountry'] = shipping_address["country"]
params['shiptozip'] = shipping_address["zip"]
params['shiptophonenum'] = shipping_address.get("phone", "")
wpp = PayPalWPP(options['request'])
try:
response = wpp.doDirectPayment(params)
transaction_was_successful.send(sender=self,
type="purchase",
response=response)
except PayPalFailure, e:
transaction_was_unsuccessful.send(sender=self,
type="purchase",
response=e)
# Slight skewness because of the way django-paypal
# is implemented.
return {"status": "FAILURE", "response": e}
def test_doReferenceTransaction_invalid(self, mock_request_object):
reference_id = 'B-1234'
amount = Decimal('10.50')
mock_request_object.return_value = 'ack=Failure&l_errorcode=42&l_longmessage0=Broken'
wpp = PayPalWPP(make_request())
with self.assertRaises(PayPalFailure):
wpp.doReferenceTransaction({'referenceid': reference_id,
'amt': amount})
def test_doDirectPayment_authenticated_user(self):
User = get_user_model()
user = User.objects.create(username='******')
wpp = PayPalWPP(make_request(user=user))
data = self.get_valid_doDirectPayment_data()
data.update(self.item)
npm_obj = wpp.doDirectPayment(data)
self.assertEqual(npm_obj.user, user)
def test_doExpressCheckoutPayment_invalid(self, mock_request_object):
ec_token = 'EC-1234567890'
payerid = 'LXYZABC1234'
item = self.ec_item.copy()
item.update({'token': ec_token, 'payerid': payerid})
mock_request_object.return_value = 'ack=Failure&l_errorcode=42&l_longmessage0=Broken'
wpp = PayPalWPP(make_request())
with self.assertRaises(PayPalFailure):
wpp.doExpressCheckoutPayment(item)
def test_doReferenceTransaction_invalid(self, mock_request_object):
reference_id = "B-1234"
amount = Decimal("10.50")
mock_request_object.return_value = "ack=Failure&l_errorcode=42&l_longmessage0=Broken"
wpp = PayPalWPP(make_request())
with self.assertRaises(PayPalFailure):
wpp.doReferenceTransaction({
"referenceid": reference_id,
"amt": amount
})
def test_doDirectPayment_valid(self):
wpp = PayPalWPP(make_request())
data = self.get_valid_doDirectPayment_data()
data.update(self.item)
nvp = wpp.doDirectPayment(data)
self.assertIsNotNone(nvp)
for k, v in [('avscode', 'X'), ('amt', '9.95'),
('correlationid', '1025431f33d89'),
('currencycode', 'USD'), ('ack', 'Success')]:
self.assertEqual(nvp.response_dict[k], v)
def save(request):
"""
Direct Paypal payment with credit card
"""
try:
cart = get_cart_data_from_request(request)
if 'order' not in request.GET:
raise Exception('no order data')
order_json = request.GET['order']
order_json = urllib.unquote(order_json)
order = json.loads(order_json)
wpp = PayPalWPP()
paypal_params = {
'ipaddress': request.META.get('REMOTE_ADDR'),
'creditcardtype': order['creditcardtype'],
'acct': order['acct'],
'expdate': order['cardmonth'] + order['cardyear'],
'cvv2': order['cvv2'],
'email': order['email'],
'firstname': order['card_first_name'],
'lastname': order['card_last_name'],
'street': order['b_street'],
'city': order['b_city'],
'state': order['b_state'],
'countrycode': order['b_countrycode'],
'zip': order['b_zip'],
'amt': cart['paymentrequest_0_amt'],
}
nvp = wpp.doDirectPayment(paypal_params)
order_data = nvp.response_dict.copy()
order_data.update(cart)
order_data.update(order)
order = create_order_from_direct_paypal(order_data)
data = {
'order_id': order.id,
}
send_order_email(order.email, order, order.items.all)
return HttpResponse(json.dumps(data), content_type='application/json')
except Exception, e:
print e
data = {'error': e.message}
return HttpResponseServerError(json.dumps(data),
content_type='application/json')
def test_createBillingAgreement(self, mock_request_object):
mock_request_object.return_value = f"ack=Success&billingagreementid=B-XXXXX&version={VERSION}"
wpp = PayPalWPP(make_request())
nvp = wpp.createBillingAgreement({"token": "dummy token"})
call_args = mock_request_object.call_args
self.assertIn(f"VERSION={VERSION}", call_args[0][1])
self.assertIn("METHOD=CreateBillingAgreement", call_args[0][1])
self.assertIn("TOKEN=dummy+token", call_args[0][1])
self.assertEqual(nvp.method, "CreateBillingAgreement")
self.assertEqual(nvp.ack, "Success")
mock_request_object.return_value = "ack=Failure&l_errorcode=42&l_longmessage0=Broken"
with self.assertRaises(PayPalFailure):
nvp = wpp.createBillingAgreement({"token": "dummy token"})
def test_createBillingAgreement(self, mock_request_object):
mock_request_object.return_value = 'ack=Success&billingagreementid=B-XXXXX&version=%s' % VERSION
wpp = PayPalWPP(make_request())
nvp = wpp.createBillingAgreement({'token': 'dummy token'})
call_args = mock_request_object.call_args
self.assertIn('VERSION=%s' % VERSION, call_args[0][1])
self.assertIn('METHOD=CreateBillingAgreement', call_args[0][1])
self.assertIn('TOKEN=dummy+token', call_args[0][1])
self.assertEqual(nvp.method, 'CreateBillingAgreement')
self.assertEqual(nvp.ack, 'Success')
mock_request_object.return_value = 'ack=Failure&l_errorcode=42&l_longmessage0=Broken'
with self.assertRaises(PayPalFailure):
nvp = wpp.createBillingAgreement({'token': 'dummy token'})
def redirect_to_express(self):
"""
First step of ExpressCheckout. Redirect the request to PayPal using the
data returned from setExpressCheckout.
"""
wpp = PayPalWPP(self.request)
try:
nvp_obj = wpp.setExpressCheckout(self.item)
except PayPalFailure:
self.context['errors'] = self.errors['paypal']
return self.render_payment_form()
else:
return HttpResponseRedirect(express_endpoint_for_token(nvp_obj.token))
def test_doDirectPayment_valid(self):
wpp = PayPalWPP(make_request())
data = self.get_valid_doDirectPayment_data()
data.update(self.item)
nvp = wpp.doDirectPayment(data)
self.assertIsNotNone(nvp)
for k, v in [
("avscode", "X"),
("amt", "9.95"),
("correlationid", "1025431f33d89"),
("currencycode", "USD"),
("ack", "Success"),
]:
self.assertEqual(nvp.response_dict[k], v)
def test_doReferenceTransaction_valid(self, mock_request_object):
reference_id = 'B-1234'
amount = Decimal('10.50')
mock_request_object.return_value = 'ack=Success&paymentstatus=Completed&amt=%s&version=%s&billingagreementid=%s' % \
(amount, VERSION, reference_id)
wpp = PayPalWPP(REQUEST)
nvp = wpp.doReferenceTransaction({'referenceid': reference_id,
'amt': amount})
call_args = mock_request_object.call_args
self.assertIn('VERSION=%s' % VERSION, call_args[0][1])
self.assertIn('METHOD=DoReferenceTransaction', call_args[0][1])
self.assertIn('REFERENCEID=%s' % reference_id, call_args[0][1])
self.assertIn('AMT=%s' % amount, call_args[0][1])
self.assertEqual(nvp.method, 'DoReferenceTransaction')
self.assertEqual(nvp.ack, 'Success')
def test_doDirectPayment_valid_with_signal(self):
wpp = PayPalWPP(make_request())
data = self.get_valid_doDirectPayment_data()
data.update(self.item)
self.got_signal = False
self.signal_obj = None
def handle_signal(sender, **kwargs):
self.got_signal = True
self.signal_obj = sender
payment_was_successful.connect(handle_signal)
self.assertTrue(wpp.doDirectPayment(data))
self.assertTrue(self.got_signal)
def test_doExpressCheckoutPayment(self, mock_request_object):
ec_token = 'EC-1234567890'
payerid = 'LXYZABC1234'
item = self.ec_item.copy()
item.update({'token': ec_token, 'payerid': payerid})
mock_request_object.return_value = 'ack=Success&token=%s&version=%spaymentinfo_0_amt=%s' % \
(ec_token, VERSION, self.ec_item['paymentrequest_0_amt'])
wpp = PayPalWPP(make_request())
wpp.doExpressCheckoutPayment(item)
call_args = mock_request_object.call_args
self.assertIn('VERSION=%s' % VERSION, call_args[0][1])
self.assertIn('METHOD=DoExpressCheckoutPayment', call_args[0][1])
self.assertIn('TOKEN=%s' % ec_token, call_args[0][1])
self.assertIn('PAYMENTREQUEST_0_AMT=%s' % item['paymentrequest_0_amt'],
call_args[0][1])
self.assertIn('PAYERID=%s' % payerid, call_args[0][1])
def redirect_to_express(self):
"""
First step of ExpressCheckout. Redirect the request to PayPal using the
data returned from setExpressCheckout.
"""
wpp = PayPalWPP(self.request)
nvp_obj = wpp.setExpressCheckout(self.item)
if not nvp_obj.flag:
pp_params = dict(token=nvp_obj.token, AMT=self.item['amt'],
RETURNURL=self.item['returnurl'],
CANCELURL=self.item['cancelurl'])
pp_url = self.get_endpoint() % urlencode(pp_params)
return HttpResponseRedirect(pp_url)
else:
self.context['errors'] = self.paypal_error
return self.render_payment_form()
def test_setExpressCheckout_deprecation(self, mock_request_object):
wpp = PayPalWPP(make_request())
mock_request_object.return_value = 'ack=Success&token=EC-XXXX&version=%s'
item = self.ec_item.copy()
item.update({'amt': item['paymentrequest_0_amt']})
del item['paymentrequest_0_amt']
with warnings.catch_warnings(record=True) as warning_list:
warnings.simplefilter("always")
nvp_obj = wpp.setExpressCheckout(item)
# Make sure our warning was given
self.assertTrue(any(warned.category == DeprecationWarning
for warned in warning_list))
# Make sure the method still went through
call_args = mock_request_object.call_args
self.assertIn('PAYMENTREQUEST_0_AMT=%s' % item['amt'],
call_args[0][1])
self.assertEqual(nvp_obj.ack, "Success")
def process(self, ipaddress, user, item):
"""Process a PayPal ExpressCheckout payment."""
from paypal.pro.helpers import PayPalWPP
wpp = PayPalWPP(ipaddress, user)
params = self.cleaned_data
params.update(item)
try:
# Create single payment:
if 'billingperiod' not in params:
nvp_obj = wpp.doExpressCheckoutPayment(params)
# Create recurring payment:
else:
nvp_obj = wpp.createRecurringPaymentsProfile(params)
except PayPalFailure:
return None
return nvp_obj
def test_doDirectPayment_invalid(self):
wpp = PayPalWPP(make_request())
data = {
'firstname': 'Epic',
'lastname': 'Fail',
'street': '100 Georgia St',
'city': 'Vancouver',
'state': 'BC',
'countrycode': 'CA',
'zip': 'V6V 1V1',
'expdate': '012019',
'cvv2': '999',
'acct': '1234567890',
'creditcardtype': 'visa',
'ipaddress': '10.0.1.199', }
data.update(self.item)
self.assertRaises(PayPalFailure, wpp.doDirectPayment, data)
def test_doDirectPayment_invalid(self):
wpp = PayPalWPP(make_request())
data = {
"firstname": "Epic",
"lastname": "Fail",
"street": "100 Georgia St",
"city": "Vancouver",
"state": "BC",
"countrycode": "CA",
"zip": "V6V 1V1",
"expdate": "012019",
"cvv2": "999",
"acct": "1234567890",
"creditcardtype": "visa",
"ipaddress": "10.0.1.199",
}
data.update(self.item)
self.assertRaises(PayPalFailure, wpp.doDirectPayment, data)
def test_doReferenceTransaction_valid(self, mock_request_object):
reference_id = "B-1234"
amount = Decimal("10.50")
mock_request_object.return_value = (
"ack=Success&paymentstatus=Completed&amt=%s&version=%s&billingagreementid=%s"
% (amount, VERSION, reference_id))
wpp = PayPalWPP(make_request())
nvp = wpp.doReferenceTransaction({
"referenceid": reference_id,
"amt": amount
})
call_args = mock_request_object.call_args
self.assertIn(f"VERSION={VERSION}", call_args[0][1])
self.assertIn("METHOD=DoReferenceTransaction", call_args[0][1])
self.assertIn(f"REFERENCEID={reference_id}", call_args[0][1])
self.assertIn(f"AMT={amount}", call_args[0][1])
self.assertEqual(nvp.method, "DoReferenceTransaction")
self.assertEqual(nvp.ack, "Success")
def process(self, request, item):
"""Process a PayPal direct payment."""
from paypal.pro.helpers import PayPalWPP
wpp = PayPalWPP(request)
params = self.cleaned_data
params['creditcardtype'] = self.fields['acct'].card_type
params['expdate'] = self.cleaned_data['expdate'].strftime("%m%Y")
params['ipaddress'] = request.META.get("REMOTE_ADDR", "")
params.update(item)
# Create single payment:
if 'billingperiod' not in params:
response = wpp.doDirectPayment(params)
# Create recurring payment:
else:
response = wpp.createRecurringPaymentsProfile(params, direct=True)
return response
def test_doExpressCheckoutPayment(self, mock_request_object):
ec_token = "EC-1234567890"
payerid = "LXYZABC1234"
item = self.ec_item.copy()
item.update({"token": ec_token, "payerid": payerid})
mock_request_object.return_value = "ack=Success&token={}&version={}paymentinfo_0_amt={}".format(
ec_token,
VERSION,
self.ec_item["paymentrequest_0_amt"],
)
wpp = PayPalWPP(make_request())
wpp.doExpressCheckoutPayment(item)
call_args = mock_request_object.call_args
self.assertIn(f"VERSION={VERSION}", call_args[0][1])
self.assertIn("METHOD=DoExpressCheckoutPayment", call_args[0][1])
self.assertIn(f"TOKEN={ec_token}", call_args[0][1])
self.assertIn(f"PAYMENTREQUEST_0_AMT={item['paymentrequest_0_amt']}",
call_args[0][1])
self.assertIn(f"PAYERID={payerid}", call_args[0][1])
def process(self, request, item):
"""Do a direct payment."""
from paypal.pro.helpers import PayPalWPP
wpp = PayPalWPP(request)
# Change the model information into a dict that PayPal can understand.
params = model_to_dict(self, exclude=self.ADMIN_FIELDS)
params['acct'] = self.acct
params['creditcardtype'] = self.creditcardtype
params['expdate'] = self.expdate
params['cvv2'] = self.cvv2
params.update(item)
# Create recurring payment:
if 'billingperiod' in params:
return wpp.createRecurringPaymentsProfile(params, direct=True)
# Create single payment:
else:
return wpp.doDirectPayment(params)
def process(self, ipaddress, user, item):
"""Process a PayPal direct payment."""
from paypal.pro.helpers import PayPalWPP
wpp = PayPalWPP(ipaddress, user)
params = self.cleaned_data
params['creditcardtype'] = self.fields['acct'].card_type
params['expdate'] = self.cleaned_data['expdate'].strftime("%m%Y")
params['ipaddress'] = ipaddress
params.update(item)
try:
# Create single payment:
if 'billingperiod' not in params:
nvp_obj = wpp.doDirectPayment(params)
# Create recurring payment:
else:
nvp_obj = wpp.createRecurringPaymentsProfile(params, direct=True)
except PayPalFailure:
return None
return nvp_obj
def validate_confirm_form(self):
"""
Third and final step of ExpressCheckout. Request has pressed the confirmation but
and we can send the final confirmation to PayPal using the data from the POST'ed form.
"""
wpp = PayPalWPP(self.request)
pp_data = dict(token=self.request.POST['token'], payerid=self.request.POST['PayerID'])
self.item.update(pp_data)
if self.is_recurring:
success = wpp.createRecurringPaymentsProfile(self.item)
else:
success = wpp.doExpressCheckoutPayment(self.item)
if success:
payment_was_successful.send(sender=self.item)
return HttpResponseRedirect(self.success_url)
else:
self.context['errors'] = self.processing_error
return self.render_payment_form()
def validate_confirm_form(self):
"""
Third and final step of ExpressCheckout. Request has pressed the confirmation but
and we can send the final confirmation to PayPal using the data from the POST'ed form.
"""
wpp = PayPalWPP(self.request)
pp_data = dict(token=self.request.POST['token'], payerid=self.request.POST['PayerID'])
self.item.update(pp_data)
# @@@ This check and call could be moved into PayPalWPP.
try:
if self.is_recurring():
nvp_obj = wpp.createRecurringPaymentsProfile(self.item)
else:
nvp_obj = wpp.doExpressCheckoutPayment(self.item)
except PayPalFailure:
self.context['errors'] = self.errors['processing']
return self.render_payment_form()
else:
return HttpResponseRedirect(self.success_url)
