def __init__(self,
verbose_name=None,
name=None,
max_digits=None,
decimal_places=None,
default=None,
default_currency=DEFAULT_CURRENCY,
currency_choices=CURRENCY_CHOICES,
**kwargs):
nullable = kwargs.get('null', False)
if default is None and not nullable:
# Backwards compatible fix for non-nullable fields
default = 0.0
if isinstance(default, basestring):
try:
# handle scenario where default is formatted like:
# 'amount currency-code'
amount, currency = default.split(" ")
except ValueError:
# value error would be risen if the default is
# without the currency part, i.e
# 'amount'
amount = default
currency = default_currency
default = Money(float(amount), Currency(code=currency))
elif isinstance(default, (float, Decimal, int)):
default = Money(default, default_currency)
if not (nullable and default is None) and not isinstance(
default, Money):
raise Exception(
"default value must be an instance of Money, is: %s" %
str(default))
# Avoid giving the user hard-to-debug errors if they miss required attributes
if max_digits is None:
raise Exception(
"You have to provide a max_digits attribute to Money fields.")
if decimal_places is None:
raise Exception(
"You have to provide a decimal_places attribute to Money fields."
)
if not default_currency:
default_currency = default.currency
self.default_currency = default_currency
self.currency_choices = currency_choices
self.frozen_by_south = kwargs.pop('frozen_by_south', False)
super(MoneyField, self).__init__(verbose_name,
name,
max_digits,
decimal_places,
default=default,
**kwargs)
def _load_currency(val):
"""Deserialize string values as standard currencies, but
manually define fully-defined currencies (with code/name/numeric/countries).
"""
from moneyed import get_currency
try:
return get_currency(code=val)
except:
return Currency(**val)
def __init__(self, name, currency, balance=0):
if not isinstance(currency, Currency):
currency = Currency(currency)
if not isinstance(balance, Money):
balance = Money(balance, currency)
if balance.currency != currency:
raise TypeError('Currency mismatch')
self.name = name
self.balance = balance
self.currency = currency
def __init__(self,
verbose_name=None,
name=None,
max_digits=None,
decimal_places=None,
default=Money(0.0, DEFAULT_CURRENCY),
default_currency=DEFAULT_CURRENCY,
currency_choices=CURRENCY_CHOICES,
**kwargs):
if isinstance(default, basestring):
amount, currency = default.split(" ")
default = Money(float(amount), Currency(code=currency))
elif isinstance(default, (float, Decimal)):
default = Money(default, default_currency)
if not isinstance(default, Money):
raise Exception(
"default value must be an instance of Money, is: %s" %
str(default))
# Avoid giving the user hard-to-debug errors if they miss required attributes
if max_digits is None:
raise Exception(
"You have to provide a max_digits attribute to Money fields.")
if decimal_places is None:
raise Exception(
"You have to provide a decimal_places attribute to Money fields."
)
if not default_currency:
default_currency = default.currency
self.default_currency = default_currency
self.currency_choices = currency_choices
self.frozen_by_south = kwargs.pop('frozen_by_south', False)
super(MoneyField, self).__init__(verbose_name,
name,
max_digits,
decimal_places,
default=default,
**kwargs)
def setup_default(self, default, default_currency, nullable):
if default is None and not nullable:
# Backwards compatible fix for non-nullable fields
default = 0.0
if isinstance(default, string_types):
try:
# handle scenario where default is formatted like:
# 'amount currency-code'
amount, currency = default.split(' ')
except ValueError:
# value error would be risen if the default is
# without the currency part, i.e
# 'amount'
amount = default
currency = default_currency
default = Money(Decimal(amount), Currency(code=currency))
elif isinstance(default, (float, Decimal, int)):
default = Money(default, default_currency)
if not (nullable and default is None) and not isinstance(default, Money):
raise ValueError('default value must be an instance of Money, is: %s' % default)
return default
def __init__(self, request):
self.charset = request.POST.get('charset', None)
logger.debug("charset: %s", self.charset)
# logger.debug("request body: %s", request.body)
ipn_log = None
if settings.IPN_LOG_ENABLED:
ipn_log = IPNLog()
ipn_log._start_time = time.time()
ipn_log.path = request.path
ipn_log.post = json.dumps(request.POST, cls=DjangoJSONEncoder)
ipn_log.save()
# verify that the request is paypal's
url = '%s?cmd=_notify-validate' % settings.PAYPAL_PAYMENT_HOST
# post_data = {}
# for k, v in request.POST.copy().iteritems():
# post_data[k] = unicode(v).encode('utf-8')
# data = urllib.urlencode(post_data)
# verify_request = UrlRequest().call(url, data=data)
verify_request = UrlRequest().call(url, data=request.body)
# check code
if verify_request.code != 200:
raise IpnError('PayPal response code was %s' % verify_request.code)
# check response
raw_response = verify_request.response
if ipn_log:
ipn_log.verify_request_response = raw_response
ipn_log.save()
if raw_response != 'VERIFIED':
raise IpnError('PayPal response was "%s"' % raw_response)
# check transaction type
raw_type = request.POST.get('transaction_type', None)
allowed_types = [
IPN_TYPE_PAYMENT,
IPN_TYPE_ADJUSTMENT,
IPN_TYPE_PREAPPROVAL,
None,
]
if raw_type in allowed_types:
self.type = raw_type
else:
raise IpnError('Unknown transaction_type received: %s' % raw_type)
self.transactions = self.process_transactions(request.POST)
try:
# payments and adjustments define these
self.status = request.POST.get('status', None)
self.sender_email = request.POST.get('sender_email', '')
self.action_type = request.POST.get('action_type', None)
self.payment_request_date = IPN.process_date(
request.POST.get('payment_request_date', None))
self.reverse_all_parallel_payments_on_error = request.POST.get(
'reverse_all_parallel_payments_on_error', 'false') == 'true'
self.return_url = request.POST.get('return_url', None)
self.cancel_url = request.POST.get('cancel_url', None)
self.ipn_notification_url = request.POST.get(
'ipn_notification_url', None)
self.pay_key = request.POST.get('pay_key', None)
self.memo = request.POST.get('memo', None)
self.fees_payer = request.POST.get('fees_payer', None)
self.trackingId = request.POST.get('trackingId', None)
self.preapproval_key = request.POST.get('preapproval_key', None)
self.reason_code = request.POST.get('reason_code', None)
# preapprovals define these
self.approved = request.POST.get('approved', 'false') == 'true'
self.current_number_of_payments = IPN.process_int(
request.POST.get('current_number_of_payments', None))
self.current_total_amount_of_all_payments = IPN.process_money(
request.POST.get('current_total_amount_of_all_payments', None))
self.current_period_attempts = IPN.process_int(
request.POST.get('current_period_attempts', None))
self.currency_code = Currency(
request.POST.get('currency_code', None))
self.date_of_month = IPN.process_int(
request.POST.get('date_of_month', None))
self.day_of_week = IPN.process_int(
request.POST.get('day_of_week', None), None)
self.starting_date = IPN.process_date(
request.POST.get('starting_date', None))
self.ending_date = IPN.process_date(
request.POST.get('ending_date', None))
self.max_total_amount_of_all_payments = Money(
request.POST.get('max_total_amount_of_all_payments', 0.0),
request.POST.get('currency_code', settings.DEFAULT_CURRENCY))
self.max_amount_per_payment = IPN.process_money(
request.POST.get('max_amount_per_payment', None))
self.max_number_of_payments = IPN.process_int(
request.POST.get('max_number_of_payments', None))
self.payment_period = request.POST.get('payment_period', None)
self.pin_type = request.POST.get('pin_type', None)
except Exception, e:
logger.error('Could not parse request')
raise e
def test_currency_user(self):
a = Currency(code='AAA', numeric=9999, name='test')
b = self.dump_and_load(a)
self.assertEqual(b.code, a.code)
self.assertEqual(b.numeric, a.numeric)
self.assertEqual(b.name, a.name)
