805 lines
31 KiB
Python
805 lines
31 KiB
Python
from regluit.payment.parameters import *
|
|
from django.core.urlresolvers import reverse
|
|
from django.conf import settings
|
|
from regluit.payment.models import Transaction, PaymentResponse
|
|
from boto.fps.connection import FPSConnection
|
|
from django.http import HttpResponse, HttpRequest, HttpResponseRedirect, HttpResponseBadRequest, HttpResponseForbidden
|
|
from datetime import timedelta
|
|
from regluit.utils.localdatetime import now, zuluformat
|
|
from boto import handler
|
|
from boto.resultset import ResultSet
|
|
from boto.exception import FPSResponseError
|
|
import xml.sax
|
|
|
|
import traceback
|
|
import datetime
|
|
import logging
|
|
import urlparse
|
|
import time
|
|
import urllib
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
AMAZON_STATUS_SUCCESS_ABT = 'SA'
|
|
AMAZON_STATUS_SUCCESS_ACH = 'SB'
|
|
AMAZON_STATUS_SUCCESS_CREDIT = 'SC'
|
|
AMAZON_STATUS_ERROR = 'SE'
|
|
AMAZON_STATUS_ADBANDONED = 'A'
|
|
AMAZON_STATUS_EXCEPTION = 'CE'
|
|
AMAZON_STATUS_PAYMENT_MISMATCH = 'PE'
|
|
AMAZON_STATUS_INCOMPLETE = 'NP'
|
|
AMAZON_STATUS_NOT_REGISTERED = 'NM'
|
|
|
|
AMAZON_STATUS_CANCELED = 'Canceled'
|
|
AMAZON_STATUS_FAILURE = 'Failure'
|
|
AMAZON_STATUS_PENDING = 'Pending'
|
|
AMAZON_STATUS_RESERVED = 'Reserved'
|
|
AMAZON_STATUS_SUCCESS = 'Success'
|
|
|
|
AMAZON_IPN_STATUS_CANCELED = 'CANCELED'
|
|
AMAZON_IPN_STATUS_FAILURE = 'FAILURE'
|
|
AMAZON_IPN_STATUS_PENDING = 'PENDING'
|
|
AMAZON_IPN_STATUS_RESERVED = 'RESERVED'
|
|
AMAZON_IPN_STATUS_SUCCESS = 'SUCCESS'
|
|
|
|
AMAZON_NOTIFICATION_TYPE_STATUS = 'TransactionStatus'
|
|
AMAZON_NOTIFICATION_TYPE_CANCEL = 'TokenCancellation'
|
|
|
|
AMAZON_OPERATION_TYPE_PAY = 'PAY'
|
|
AMAZON_OPERATION_TYPE_REFUND = 'REFUND'
|
|
AMAZON_OPERATION_TYPE_CANCEL = 'CANCEL'
|
|
|
|
# load FPS_ACCESS_KEY and FPS_SECRET_KEY from the database if possible
|
|
|
|
try:
|
|
from regluit.core.models import Key
|
|
FPS_ACCESS_KEY = Key.objects.get(name="FPS_ACCESS_KEY").value
|
|
FPS_SECRET_KEY = Key.objects.get(name="FPS_SECRET_KEY").value
|
|
except:
|
|
FPS_ACCESS_KEY = ''
|
|
FPS_SECRET_KEY = ''
|
|
|
|
|
|
def ProcessIPN(request):
|
|
'''
|
|
IPN handler for amazon. Here is a litle background on amazon IPNS
|
|
http://docs.amazonwebservices.com/AmazonFPS/latest/FPSAdvancedGuide/APPNDX_IPN.html
|
|
|
|
notificationType: Can either be TransactionStatus of TokenCancellation
|
|
status: One of the defined IPN status codes
|
|
operation: The type of operation
|
|
callerReference: The reference to find the transaction
|
|
|
|
The IPN is called for the following cases:
|
|
|
|
A payment or reserve succeeds
|
|
A payment or reserve fails
|
|
A payment or reserve goes into a pending state
|
|
A reserved payment is settled successfully
|
|
A reserved payment is not settled successfully
|
|
A refund succeeds
|
|
A refund fails
|
|
A refund goes into a pending state
|
|
A payment is canceled
|
|
A reserve is canceled
|
|
A token is canceled successfully
|
|
|
|
'''
|
|
try:
|
|
logging.debug("Amazon IPN called")
|
|
|
|
uri = request.build_absolute_uri()
|
|
parsed_url = urlparse.urlparse(uri)
|
|
|
|
connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
|
|
# Check the validity of the IPN
|
|
resp = connection.verify_signature("%s://%s%s" %(parsed_url.scheme,
|
|
parsed_url.netloc,
|
|
parsed_url.path),
|
|
request.raw_post_data)
|
|
|
|
if not resp[0].VerificationStatus == "Success":
|
|
# Error, ignore this IPN
|
|
logging.error("Amazon IPN cannot be verified with post data: ")
|
|
logging.error(request.raw_post_data)
|
|
return HttpResponseForbidden()
|
|
|
|
logging.debug("Amazon IPN post data:")
|
|
logging.debug(request.POST)
|
|
|
|
reference = request.POST['callerReference']
|
|
type = request.POST['notificationType']
|
|
|
|
# In the case of cancelling a token, there is no transaction, so this info is not set
|
|
transactionId = request.POST.get('transactionId', None)
|
|
date = request.POST.get('transactionDate', None)
|
|
operation = request.POST.get('operation', None)
|
|
status = request.POST.get('transactionStatus', None)
|
|
|
|
logging.info("Received Amazon IPN with the following data:")
|
|
logging.info("type = %s" % type)
|
|
logging.info("operation = %s" % operation)
|
|
logging.info("reference = %s" % reference)
|
|
logging.info("status = %s" % status)
|
|
|
|
# We should always find the transaction by the token
|
|
transaction = Transaction.objects.get(secret=reference)
|
|
|
|
if type == AMAZON_NOTIFICATION_TYPE_STATUS:
|
|
|
|
|
|
# status update for the token, save the actual value
|
|
transaction.local_status = status
|
|
|
|
# Now map our local status to the global status codes
|
|
if operation == AMAZON_OPERATION_TYPE_PAY:
|
|
|
|
|
|
if status == AMAZON_IPN_STATUS_SUCCESS:
|
|
transaction.status = TRANSACTION_STATUS_COMPLETE
|
|
|
|
elif status == AMAZON_IPN_STATUS_PENDING:
|
|
|
|
if transaction.status == TRANSACTION_STATUS_CREATED:
|
|
#
|
|
# Per the amazon documentation:
|
|
# If your IPN receiving service is down for some time, it is possible that our retry mechanism will deliver the IPNs out of order.
|
|
# If you receive an IPN for TransactionStatus (IPN), as SUCCESS or FAILURE or RESERVED,
|
|
# then after that time ignore any IPN that gives the PENDING status for the transaction
|
|
#
|
|
transaction.status = TRANSACTION_STATUS_PENDING
|
|
else:
|
|
transaction.status = TRANSACTION_STATUS_ERROR
|
|
|
|
elif operation == AMAZON_OPERATION_TYPE_REFUND:
|
|
|
|
if status == AMAZON_IPN_STATUS_SUCCESS:
|
|
transaction.status = TRANSACTION_STATUS_REFUNDED
|
|
elif status == AMAZON_IPN_STATUS_PENDING:
|
|
transaction.status = TRANSACTION_STATUS_PENDING
|
|
else:
|
|
transaction.status = TRANSACTION_STATUS_ERROR
|
|
|
|
elif operation == AMAZON_OPERATION_TYPE_CANCEL:
|
|
|
|
if status == AMAZON_IPN_STATUS_SUCCESS:
|
|
transaction.status = TRANSACTION_STATUS_COMPLETE
|
|
else:
|
|
transaction.status = TRANSACTION_STATUS_ERROR
|
|
|
|
|
|
elif type == AMAZON_NOTIFICATION_TYPE_CANCEL:
|
|
#
|
|
# The cancel IPN does not have a transaction ID or transaction status, so make them up
|
|
#
|
|
transaction.local_status = AMAZON_IPN_STATUS_CANCELED
|
|
transaction.status = TRANSACTION_STATUS_CANCELED
|
|
status = AMAZON_IPN_STATUS_CANCELED
|
|
|
|
|
|
transaction.save()
|
|
|
|
#
|
|
# This is currently not done in paypal land, but log this IPN since the amazon IPN has good info
|
|
#
|
|
PaymentResponse.objects.create(api="IPN",
|
|
correlation_id = transactionId,
|
|
timestamp = date,
|
|
info = str(request.POST),
|
|
status=status,
|
|
transaction=transaction)
|
|
|
|
return HttpResponse("Complete")
|
|
|
|
except:
|
|
traceback.print_exc()
|
|
return HttpResponseForbidden()
|
|
|
|
|
|
def amazonPaymentReturn(request):
|
|
'''
|
|
This is the complete view called after the co-branded API completes. It is called whenever the user
|
|
approves a preapproval or a pledge. This URL is set via the PAY api.
|
|
'''
|
|
try:
|
|
|
|
# pick up all get and post parameters and display
|
|
output = "payment complete"
|
|
output += request.method + "\n" + str(request.REQUEST.items())
|
|
|
|
signature = request.GET['signature']
|
|
reference = request.GET['callerReference']
|
|
token = request.GET['tokenID']
|
|
status = request.GET['status']
|
|
|
|
# BUGUBG - Should we verify the signature here?
|
|
#
|
|
# Find the transaction by reference, there should only be one
|
|
# We will catch the exception if it does not exist
|
|
#
|
|
transaction = Transaction.objects.get(secret=reference)
|
|
|
|
logging.info("Amazon Co-branded Return URL called for transaction id: %d" % transaction.id)
|
|
logging.info(request.GET)
|
|
|
|
#
|
|
# BUGBUG, for now lets map amazon status code to paypal, just to keep things uninform
|
|
#
|
|
if transaction.type == PAYMENT_TYPE_INSTANT:
|
|
# Instant payments need to be executed now
|
|
|
|
# Log the authorize transaction
|
|
r = PaymentResponse.objects.create(api="Authorize",
|
|
correlation_id = "None",
|
|
timestamp = str(datetime.datetime.now()),
|
|
info = str(request.GET),
|
|
status=status,
|
|
transaction=transaction)
|
|
|
|
if status == AMAZON_STATUS_SUCCESS_ABT or status == AMAZON_STATUS_SUCCESS_ACH or status == AMAZON_STATUS_SUCCESS_CREDIT:
|
|
# The above status code are unique to the return URL and are different than the pay API codes
|
|
|
|
# Store the token, we need this for the IPN.
|
|
transaction.pay_key = token
|
|
|
|
#
|
|
# BUGBUG, need to handle multiple recipients
|
|
# Send the pay request now to ourselves
|
|
#
|
|
e = Execute(transaction=transaction)
|
|
|
|
if e.success() and not e.error():
|
|
# Success case, save the ID. Our IPN will update the status
|
|
print "Amazon Execute returned succesfully"
|
|
|
|
else:
|
|
logging.error("Amazon payment execution failed: ")
|
|
logging.error(e.envelope())
|
|
transaction.status = TRANSACTION_STATUS_ERROR
|
|
|
|
# Log the pay transaction
|
|
r = PaymentResponse.objects.create(api="Pay",
|
|
correlation_id = e.correlation_id(),
|
|
timestamp = e.timestamp(),
|
|
info = e.envelope(),
|
|
status = e.status,
|
|
transaction=transaction)
|
|
|
|
else:
|
|
# We may never see an IPN, set the status here
|
|
logging.error("Amazon payment authorization failed: ")
|
|
logging.error(request.GET)
|
|
transaction.status = AMAZON_STATUS_FAILURE
|
|
|
|
|
|
elif transaction.type == PAYMENT_TYPE_AUTHORIZATION:
|
|
#
|
|
# Future payments, we only need to store the token. The authorization was requested with the default expiration
|
|
# date set in our settings. When we are ready, we can call execute on this
|
|
#
|
|
transaction.local_status = status
|
|
|
|
if status == AMAZON_STATUS_SUCCESS_ABT or status == AMAZON_STATUS_SUCCESS_ACH or status == AMAZON_STATUS_SUCCESS_CREDIT:
|
|
|
|
# The above status code are unique to the return URL and are different than the pay API codes
|
|
transaction.status = TRANSACTION_STATUS_ACTIVE
|
|
transaction.approved = True
|
|
transaction.pay_key = token
|
|
|
|
else:
|
|
# We may never see an IPN, set the status here
|
|
transaction.status = TRANSACTION_STATUS_ERROR
|
|
|
|
# Log the trasaction
|
|
r = PaymentResponse.objects.create(api="Authorize",
|
|
correlation_id = "None",
|
|
timestamp = str(datetime.datetime.now()),
|
|
info = str(request.GET),
|
|
status = status,
|
|
transaction=transaction)
|
|
|
|
transaction.save()
|
|
|
|
# Redirect to our pledge success URL
|
|
return_path = "{0}?{1}".format(reverse('pledge_complete'),
|
|
urllib.urlencode({'tid':transaction.id}))
|
|
return_url = urlparse.urljoin(settings.BASE_URL, return_path)
|
|
return HttpResponseRedirect(return_url)
|
|
|
|
except:
|
|
logging.error("Amazon co-branded return-url FAILED with exception:")
|
|
traceback.print_exc()
|
|
|
|
cancel_path = "{0}?{1}".format(reverse('pledge_cancel'),
|
|
urllib.urlencode({'tid':transaction.id}))
|
|
cancel_url = urlparse.urljoin(settings.BASE_URL, cancel_path)
|
|
|
|
return HttpResponseRedirect(cancel_url)
|
|
|
|
|
|
class AmazonRequest:
|
|
'''
|
|
Handles common information that is processed from the response envelope of the amazon request.
|
|
|
|
'''
|
|
|
|
# Global values for the class
|
|
response = None
|
|
raw_response = None
|
|
errorMessage = None
|
|
status = None
|
|
url = None
|
|
|
|
def ack( self ):
|
|
return None
|
|
|
|
def success(self):
|
|
|
|
print "CALLING SUCCESS"
|
|
if self.errorMessage:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def error(self):
|
|
if self.errorMessage:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def error_data(self):
|
|
return None
|
|
|
|
def error_id(self):
|
|
return None
|
|
|
|
def error_string(self):
|
|
|
|
return self.errorMessage
|
|
|
|
def envelope(self):
|
|
|
|
# The envelope is used to store info about this request
|
|
if self.response:
|
|
return str(self.response)
|
|
else:
|
|
return None
|
|
|
|
def correlation_id(self):
|
|
# The correlation ID is unique to each API call
|
|
if self.response:
|
|
return self.response.TransactionId
|
|
else:
|
|
return None
|
|
|
|
def timestamp(self):
|
|
return str(datetime.datetime.now())
|
|
|
|
|
|
class Pay( AmazonRequest ):
|
|
|
|
'''
|
|
The pay function generates a redirect URL to approve the transaction
|
|
'''
|
|
|
|
def __init__( self, transaction, return_url=None, cancel_url=None, amount=None):
|
|
|
|
try:
|
|
logging.debug("Amazon PAY operation for transaction ID %d" % transaction.id)
|
|
|
|
# Replace our return URL with a redirect through our internal URL
|
|
self.original_return_url = return_url
|
|
return_url = settings.BASE_URL + reverse('AmazonPaymentReturn')
|
|
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
|
|
receiver_list = []
|
|
receivers = transaction.receiver_set.all()
|
|
|
|
if not amount:
|
|
amount = 0
|
|
for r in receivers:
|
|
amount += r.amount
|
|
|
|
logger.info(receiver_list)
|
|
|
|
# Data fields for amazon
|
|
|
|
expiry = now() + timedelta( days=settings.PREAPPROVAL_PERIOD )
|
|
|
|
data = {
|
|
'amountType':'Maximum', # The transaction amount is the maximum amount
|
|
'callerReference': transaction.secret,
|
|
'currencyCode': 'USD',
|
|
'globalAmountLimit': str(amount),
|
|
'validityExpiry': str(int(time.mktime(expiry.timetuple()))), # use the preapproval date by default
|
|
}
|
|
|
|
self.url = self.connection.make_url(return_url, "Test Payment", "MultiUse", str(amount), **data)
|
|
|
|
logging.debug("Amazon PAY redirect url was: %s" % self.url)
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
logging.error("Amazon PAY api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
logging.error("Amazon PAY FAILED with exception:")
|
|
traceback.print_exc()
|
|
self.errorMessage = "Error: Server Error"
|
|
|
|
def api(self):
|
|
return "Amazon Co-branded PAY request"
|
|
|
|
def exec_status( self ):
|
|
return None
|
|
|
|
def amount( self ):
|
|
return None
|
|
|
|
def key( self ):
|
|
return None
|
|
|
|
def next_url( self ):
|
|
return self.url
|
|
|
|
def embedded_url(self):
|
|
return None
|
|
|
|
class Preapproval(Pay):
|
|
|
|
def __init__( self, transaction, amount, expiry=None, return_url=None, cancel_url=None):
|
|
|
|
# set the expiration date for the preapproval if not passed in. This is what the paypal library does
|
|
now_val = now()
|
|
if expiry is None:
|
|
expiry = now_val + timedelta( days=settings.PREAPPROVAL_PERIOD )
|
|
transaction.date_authorized = now_val
|
|
transaction.date_expired = expiry
|
|
transaction.save()
|
|
|
|
# Call into our parent class
|
|
Pay.__init__(self, transaction, return_url=return_url, cancel_url=cancel_url, amount=amount)
|
|
|
|
|
|
class Execute(AmazonRequest):
|
|
|
|
'''
|
|
The Execute function sends an existing token(generated via the URL from the pay operation), and collects
|
|
the money.
|
|
'''
|
|
|
|
def __init__(self, transaction=None):
|
|
|
|
try:
|
|
logging.debug("Amazon EXECUTE action for transaction id: %d" % transaction.id)
|
|
|
|
# Use the boto class top open a connection
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
self.transaction = transaction
|
|
|
|
# BUGBUG, handle multiple receivers! For now we just send the money to ourselves
|
|
|
|
self.raw_response = self.connection.pay(transaction.amount,
|
|
transaction.pay_key,
|
|
recipientTokenId=None,
|
|
callerReference=transaction.secret,
|
|
senderReference=None,
|
|
recipientReference=None,
|
|
senderDescription=None,
|
|
recipientDescription=None,
|
|
callerDescription=None,
|
|
metadata=None,
|
|
transactionDate=None,
|
|
reserve=False)
|
|
|
|
#
|
|
# BUGBUG:
|
|
# The boto FPS library throws an exception if an error is generated, we need to do a better
|
|
# job of reporting the error when this occurs
|
|
#
|
|
|
|
self.response = self.raw_response[0]
|
|
logging.debug("Amazon EXECUTE response for transaction id: %d" % transaction.id)
|
|
logging.debug(str(self.response))
|
|
|
|
self.status = self.response.TransactionStatus
|
|
|
|
#
|
|
# For amazon, the transactionID is per transaction, not per receiver. For now we will store it in the preapproval key field
|
|
# so we can use it to refund or get status later
|
|
#
|
|
transaction.preapproval_key = self.response.TransactionId
|
|
|
|
logging.debug("Amazon EXECUTE API returning with variables:")
|
|
logging.debug(locals())
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
|
|
logging.error("Amazon EXECUTE api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
logging.error("Amazon EXECUTE FAILED with exception:")
|
|
traceback.print_exc()
|
|
self.errorMessage = "Error: Server Error"
|
|
|
|
def api(self):
|
|
return "Amazon API Pay"
|
|
|
|
def key(self):
|
|
# IN paypal land, our key is updated from a preapproval to a pay key here, just return the existing key
|
|
return self.transaction.pay_key
|
|
|
|
|
|
|
|
class Finish(AmazonRequest):
|
|
'''
|
|
The Finish function handles the secondary receiver in a chained payment. Currently not implemented
|
|
for amazon
|
|
'''
|
|
def __init__(self, transaction):
|
|
|
|
try:
|
|
|
|
print "Finish"
|
|
|
|
except:
|
|
traceback.print_exc()
|
|
self.errorMessage = "Error: Server Error"
|
|
|
|
class PaymentDetails(AmazonRequest):
|
|
'''
|
|
Get details about executed PAY operation
|
|
|
|
This api must set the following class variables to work with the code in manager.py
|
|
|
|
status - one of the global transaction status codes
|
|
transactions -- Not supported for amazon, used by paypal
|
|
|
|
'''
|
|
def __init__(self, transaction=None):
|
|
|
|
try:
|
|
logging.debug("Amazon PAYMENTDETAILS API for transaction id: %d" % transaction.id)
|
|
|
|
# Use the boto class top open a connection
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
self.transaction = transaction
|
|
|
|
if not transaction.preapproval_key:
|
|
# This is where we store the transaction ID
|
|
self.errorMessage = "No Valid Transaction ID"
|
|
return
|
|
|
|
#
|
|
# We need to reference the transaction ID here, this is stored in the preapproval_key as this
|
|
# field is not used for amazon
|
|
#
|
|
self.raw_response = self.connection.get_transaction_status(transaction.preapproval_key)
|
|
self.response = self.raw_response[0]
|
|
|
|
logging.debug("Amazon PAYMENTDETAILS API for transaction id: %d returned response:")
|
|
logging.debug(self.response)
|
|
|
|
#
|
|
# Now we need to build values to match the paypal response.
|
|
# The two we need are status and and array of transactions.
|
|
#
|
|
|
|
# Check our status codes, note that these are different than the IPN status codes
|
|
self.local_status = self.response.StatusCode
|
|
self.message = self.response.StatusMessage
|
|
|
|
|
|
if self.local_status == 'Canceled':
|
|
self.status = TRANSACTION_STATUS_CANCELED
|
|
|
|
elif self.local_status == 'Success':
|
|
#
|
|
# Note, there is a limitation here. If the current status is refunded, this API will return "Success".
|
|
# We must be careful to not overwrite refunded status codes. There is no way that I can find to poll
|
|
# to see if a transaction is refunded. I need to investigate all of the data fields and see if we can find
|
|
# that information
|
|
#
|
|
if transaction.status != TRANSACTION_STATUS_REFUNDED:
|
|
self.status = TRANSACTION_STATUS_COMPLETE
|
|
else:
|
|
self.status = TRANSACTION_STATUS_REFUNDED
|
|
|
|
elif self.local_status == 'PendingNetworkResponse' or self.local_status == 'PendingVerification':
|
|
self.status = TRANSACTION_STATUS_PENDING
|
|
elif self.local_status == 'TransactionDenied':
|
|
self.status = TRANSACTION_STATUS_FAILED
|
|
else:
|
|
self.status = TRANSACTION_STATUS_ERROR
|
|
|
|
# Amazon does not support receivers at this point
|
|
self.transactions = []
|
|
|
|
logging.debug("Amazon PAYMENTDETAILS API returning with variables:")
|
|
logging.debug(locals())
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
|
|
logging.error("Amazon PAYMENTDETAILS api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
logging.error("Amazon PAYMENTDETAILS FAILED with exception:")
|
|
self.errorMessage = "Error: ServerError"
|
|
traceback.print_exc()
|
|
|
|
|
|
|
|
class CancelPreapproval(AmazonRequest):
|
|
'''
|
|
Cancels an exisiting token. The current boto FPS library does not directly support
|
|
the CancelToken API, just the Cancel API(for real money in-flight or reserved).
|
|
'''
|
|
|
|
def __init__(self, transaction):
|
|
|
|
try:
|
|
logging.debug("Amazon CANCELPREAPPROVAL api called for transaction id: %d" % transaction.id)
|
|
|
|
# Use the boto class top open a connection
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
self.transaction = transaction
|
|
|
|
params = {}
|
|
params['TokenId'] = transaction.pay_key
|
|
params['ReasonText'] = "Cancel Reason"
|
|
|
|
fps_response = self.connection.make_request("CancelToken", params)
|
|
|
|
body = fps_response.read()
|
|
print body
|
|
if(fps_response.status == 200):
|
|
|
|
rs = ResultSet()
|
|
h = handler.XmlHandler(rs, self)
|
|
xml.sax.parseString(body, h)
|
|
|
|
if rs:
|
|
self.raw_response = rs
|
|
self.response = self.raw_response[0]
|
|
self.status = self.response.TransactionStatus
|
|
self.errorMessage = None
|
|
|
|
else:
|
|
#
|
|
# Set an error message and failure status for
|
|
# our success() and error() functions
|
|
#
|
|
self.status = AMAZON_STATUS_FAILURE
|
|
self.errorMessage = "%s - %s" % (fps_response.reason, body)
|
|
|
|
logging.debug("Amazon CANCELPREAPPROVAL API returning with variables:")
|
|
logging.debug(locals())
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
|
|
logging.error("Amazon CANCELPREAPPROVAL api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
logging.error("Amazon CANCELPREAPPROVAL FAILED with exception:")
|
|
traceback.print_exc()
|
|
self.errorMessage = "Error: Server Error"
|
|
|
|
|
|
class RefundPayment(AmazonRequest):
|
|
|
|
def __init__(self, transaction):
|
|
|
|
try:
|
|
logging.debug("Amazon REFUNDPAYMENT API called for transaction id: %d", transaction.id)
|
|
|
|
# Use the boto class top open a connection
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
self.transaction = transaction
|
|
|
|
if not transaction.preapproval_key:
|
|
# This is where we store the transaction ID
|
|
self.errorMessage = "No Valid Transaction ID"
|
|
return
|
|
|
|
#
|
|
# We need to reference the transaction ID here, this is stored in the preapproval_key as this
|
|
# field is not used for amazon
|
|
#
|
|
self.raw_response = self.connection.refund(transaction.secret, transaction.preapproval_key)
|
|
self.response = self.raw_response[0]
|
|
|
|
logging.debug("Amazon REFUNDPAYMENT response was:")
|
|
logging.debug(str(self.response))
|
|
|
|
self.status = self.response.TransactionStatus
|
|
|
|
logging.debug("Amazon REFUNDPAYMENT API returning with variables:")
|
|
logging.debug(locals())
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
|
|
logging.error("Amazon REFUNDPAYMENT api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
logging.error("Amazon REFUNDPAYMENT FAILED with exception:")
|
|
traceback.print_exc()
|
|
self.errorMessage = "Error: Server Error"
|
|
|
|
|
|
class PreapprovalDetails(AmazonRequest):
|
|
'''
|
|
Get details about an authorized token
|
|
|
|
This api must set 4 different class variables to work with the code in manager.py
|
|
|
|
status - one of the global transaction status codes
|
|
approved - boolean value
|
|
currency - not used in this API, but we can get some more info via other APIs - TODO
|
|
amount - not used in this API, but we can get some more info via other APIs - TODO
|
|
|
|
'''
|
|
def __init__(self, transaction=None):
|
|
|
|
try:
|
|
logging.debug("Amazon PREAPPROVALDETAILS API called for transaction id: %d", transaction.id)
|
|
|
|
# Use the boto class top open a connection
|
|
self.connection = FPSConnection(FPS_ACCESS_KEY, FPS_SECRET_KEY, host=settings.AMAZON_FPS_HOST)
|
|
self.transaction = transaction
|
|
|
|
|
|
#
|
|
# We need to reference the caller reference here, we may not have a token if the return URL failed
|
|
#
|
|
self.raw_response = self.connection.get_token_by_caller_reference(transaction.secret)
|
|
self.response = self.raw_response
|
|
|
|
logging.debug("Amazon PREAPPROVALDETAILS response:")
|
|
logging.debug(str(self.response))
|
|
|
|
#
|
|
# Look for a token, we store this in the pay_key field
|
|
#
|
|
self.pay_key = self.response.TokenId
|
|
self.local_status = self.response.TokenStatus
|
|
|
|
# Possible status for the Token object are Active and Inactive
|
|
if self.local_status == 'Active':
|
|
self.status = TRANSACTION_STATUS_ACTIVE
|
|
self.approved = True
|
|
else:
|
|
# It is not clear here if this should be failed or cancelled, but we have no way to know
|
|
# the token is only active or now, so we will assume it is canceled.
|
|
self.status = TRANSACTION_STATUS_CANCELED
|
|
self.approved = False
|
|
|
|
# Set the other fields that are expected. We don't have values for these now, so just copy the transaction
|
|
self.currency = transaction.currency
|
|
self.amount = transaction.amount
|
|
|
|
logging.debug("Amazon PREAPPROVALDETAILS API returning with variables:")
|
|
logging.debug(locals())
|
|
|
|
except FPSResponseError as (responseStatus, responseReason, body):
|
|
|
|
logging.error("Amazon PREAPPROVALDETAILS api failed with status: %s, reason: %s and data:" % (responseStatus, responseReason))
|
|
logging.error(body)
|
|
self.errorMessage = body
|
|
|
|
except:
|
|
# If the boto API fails, it also throws an exception and we end up here
|
|
logging.error("Amazon PREAPPROVALDETAILS FAILED with exception:")
|
|
self.errorMessage = "Error: ServerError"
|
|
traceback.print_exc()
|
|
|