386 lines
16 KiB
Python
386 lines
16 KiB
Python
from django.db import models
|
|
from django.contrib.auth.models import User
|
|
from django.conf import settings
|
|
from django.db.models import Q
|
|
|
|
from regluit.payment.parameters import *
|
|
from regluit.payment.signals import credit_balance_added, pledge_created
|
|
from regluit.utils.localdatetime import now
|
|
|
|
from django.db.models.signals import post_save, post_delete
|
|
|
|
from decimal import Decimal
|
|
import datetime
|
|
import uuid
|
|
import urllib
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# in fitting stripe -- here are possible fields to fit in with Transaction
|
|
# c.id, c.amount, c.amount_refunded, c.currency, c.description, datetime.fromtimestamp(c.created, tz=utc), c.paid,
|
|
# c.fee, c.disputed, c.amount_refunded, c.failure_message,
|
|
# c.card.fingerprint, c.card.type, c.card.last4, c.card.exp_month, c.card.exp_year
|
|
|
|
# promising fields
|
|
|
|
class Transaction(models.Model):
|
|
|
|
# type e.g., PAYMENT_TYPE_INSTANT or PAYMENT_TYPE_AUTHORIZATION -- defined in parameters.py
|
|
type = models.IntegerField(default=PAYMENT_TYPE_NONE, null=False)
|
|
|
|
# host: the payment processor. Named after the payment module that hosts the payment processing functions
|
|
host = models.CharField(default=PAYMENT_HOST_NONE, max_length=32, null=False)
|
|
|
|
#execution: e.g. EXECUTE_TYPE_CHAINED_INSTANT, EXECUTE_TYPE_CHAINED_DELAYED, EXECUTE_TYPE_PARALLEL
|
|
execution = models.IntegerField(default=EXECUTE_TYPE_NONE, null=False)
|
|
|
|
# status: general status constants defined in parameters.py
|
|
status = models.CharField(max_length=32, default=TRANSACTION_STATUS_NONE, null=False)
|
|
|
|
# local_status: status code specific to the payment processor
|
|
local_status = models.CharField(max_length=32, default='NONE', null=True)
|
|
|
|
# amount & currency -- amount of money and its currency involved for transaction
|
|
amount = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
max_amount = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
currency = models.CharField(max_length=10, default='USD', null=True)
|
|
|
|
# a unique ID that can be passed to PayPal to track a transaction
|
|
secret = models.CharField(max_length=64, null=True)
|
|
|
|
# a paykey that PayPal generates to identify this transaction
|
|
pay_key = models.CharField(max_length=128, null=True)
|
|
|
|
# a preapproval key that Paypal generates to identify this transaction
|
|
preapproval_key = models.CharField(max_length=128, null=True)
|
|
|
|
# (RY is not sure what receipt is for)
|
|
receipt = models.CharField(max_length=256, null=True)
|
|
|
|
# whether a Preapproval has been approved or not
|
|
approved = models.NullBooleanField(null=True)
|
|
|
|
# error message from a transaction
|
|
error = models.CharField(max_length=256, null=True)
|
|
|
|
# IPN.reason_code
|
|
reason = models.CharField(max_length=64, null=True)
|
|
|
|
# creation and last modified timestamps
|
|
date_created = models.DateTimeField(auto_now_add=True)
|
|
date_modified = models.DateTimeField(auto_now=True)
|
|
|
|
# date_payment: when an attempt is made to make the primary payment
|
|
date_payment = models.DateTimeField(null=True)
|
|
|
|
# date_executed: when an attempt is made to send money to non-primary chained receivers
|
|
date_executed = models.DateTimeField(null=True)
|
|
|
|
# datetime for creation of preapproval and for its expiration
|
|
date_authorized = models.DateTimeField(null=True)
|
|
date_expired = models.DateTimeField(null=True)
|
|
|
|
# associated User, Campaign, and Premium for this Transaction
|
|
user = models.ForeignKey(User, null=True)
|
|
campaign = models.ForeignKey('core.Campaign', null=True)
|
|
premium = models.ForeignKey('core.Premium', null=True)
|
|
|
|
# how to acknowledge the user on the supporter page of the campaign ebook
|
|
ack_name = models.CharField(max_length=64, null=True)
|
|
ack_dedication = models.CharField(max_length=140, null=True)
|
|
|
|
# whether the user wants to be not listed publicly
|
|
anonymous = models.BooleanField(null=False)
|
|
|
|
@property
|
|
def tier(self):
|
|
if self.amount < 25:
|
|
return 0
|
|
if self.amount < 50:
|
|
return 1
|
|
if self.amount < 100:
|
|
return 2
|
|
else:
|
|
return 3
|
|
|
|
@property
|
|
def ack_link(self):
|
|
return 'https://unglue.it/supporter/%s' % urllib.quote(self.user.username) if not self.anonymous else ''
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.secret:
|
|
self.secret = str(uuid.uuid1())
|
|
super(Transaction, self).save(*args, **kwargs) # Call the "real" save() method.
|
|
|
|
def __unicode__(self):
|
|
return u"-- Transaction:\n \tstatus: %s\n \t amount: %s\n \terror: %s\n" % (self.status, str(self.amount), self.error)
|
|
|
|
def create_receivers(self, receiver_list):
|
|
|
|
primary = True
|
|
for r in receiver_list:
|
|
receiver = Receiver.objects.create(email=r['email'], amount=r['amount'], currency=self.currency, status="None", primary=primary, transaction=self)
|
|
primary = False
|
|
|
|
def get_payment_class(self):
|
|
'''
|
|
Returns the specific payment processor that implements this transaction
|
|
'''
|
|
if self.host == PAYMENT_HOST_NONE:
|
|
return None
|
|
else:
|
|
mod = __import__("regluit.payment." + self.host, fromlist=[str(self.host)])
|
|
return mod.Processor()
|
|
|
|
def set_credit_approved(self, amount):
|
|
self.amount=amount
|
|
self.host = PAYMENT_HOST_CREDIT
|
|
self.type = PAYMENT_TYPE_AUTHORIZATION
|
|
self.status=TRANSACTION_STATUS_ACTIVE
|
|
self.approved=True
|
|
now_val = now()
|
|
self.date_authorized = now_val
|
|
self.date_expired = now_val + datetime.timedelta( days=settings.PREAPPROVAL_PERIOD )
|
|
self.save()
|
|
pledge_created.send(sender=self, transaction=self)
|
|
|
|
def set_pledge_extra(self, pledge_extra):
|
|
if pledge_extra:
|
|
self.anonymous = pledge_extra.anonymous
|
|
self.premium = pledge_extra.premium
|
|
self.ack_name = pledge_extra.ack_name
|
|
self.ack_dedication = pledge_extra.ack_dedication
|
|
|
|
def get_pledge_extra(self):
|
|
class pe:
|
|
premium=self.premium
|
|
anonymous=self.anonymous
|
|
ack_name=self.ack_name
|
|
ack_dedication=self.ack_dedication
|
|
return pe
|
|
|
|
@classmethod
|
|
def create(cls,amount=0.00, host=PAYMENT_HOST_NONE, max_amount=0.00, currency='USD',
|
|
status=TRANSACTION_STATUS_NONE,campaign=None, user=None, pledge_extra=None):
|
|
if pledge_extra:
|
|
return cls.objects.create(amount=amount,
|
|
host=host,
|
|
max_amount=max_amount,
|
|
currency=currency,
|
|
status=status,
|
|
campaign=campaign,
|
|
user=user,
|
|
premium=pledge_extra.premium,
|
|
anonymous=pledge_extra.anonymous,
|
|
ack_name=pledge_extra.ack_name,
|
|
ack_dedication=pledge_extra.ack_dedication
|
|
)
|
|
else:
|
|
return cls.objects.create(amount=amount, host=host, max_amount=max_amount, currency=currency,status=status,
|
|
campaign=campaign, user=user)
|
|
|
|
class PaymentResponse(models.Model):
|
|
# The API used
|
|
api = models.CharField(max_length=64, null=False)
|
|
|
|
# The correlation ID
|
|
correlation_id = models.CharField(max_length=512, null=True)
|
|
|
|
# the paypal timestamp
|
|
timestamp = models.CharField(max_length=128, null=True)
|
|
|
|
# extra info we want to store if an error occurs such as the response message
|
|
info = models.CharField(max_length=1024, null=True)
|
|
|
|
# local status specific to the api call
|
|
status = models.CharField(max_length=32, null=True)
|
|
|
|
transaction = models.ForeignKey(Transaction, null=False)
|
|
|
|
def __unicode__(self):
|
|
return u"PaymentResponse -- api: {0} correlation_id: {1} transaction: {2}".format(self.api, self.correlation_id, unicode(self.transaction))
|
|
|
|
|
|
class Receiver(models.Model):
|
|
|
|
email = models.CharField(max_length=64)
|
|
|
|
amount = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
currency = models.CharField(max_length=10)
|
|
|
|
status = models.CharField(max_length=64)
|
|
local_status = models.CharField(max_length=64, null=True)
|
|
reason = models.CharField(max_length=64)
|
|
primary = models.BooleanField()
|
|
txn_id = models.CharField(max_length=64)
|
|
transaction = models.ForeignKey(Transaction)
|
|
|
|
def __unicode__(self):
|
|
return u"Receiver -- email: {0} status: {1} transaction: {2}".format(self.email, self.status, unicode(self.transaction))
|
|
|
|
class CreditLog(models.Model):
|
|
# a write only record of Donation Credit Transactions
|
|
user = models.ForeignKey(User, null=True)
|
|
amount = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
timestamp = models.DateTimeField(auto_now=True)
|
|
action = models.CharField(max_length=16)
|
|
# used to record the sent id when action = 'deposit'
|
|
sent=models.IntegerField(null=True)
|
|
|
|
class Credit(models.Model):
|
|
user = models.OneToOneField(User, related_name='credit')
|
|
balance = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
pledged = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
last_activity = models.DateTimeField(auto_now=True)
|
|
|
|
@property
|
|
def available(self):
|
|
return self.balance - self.pledged
|
|
|
|
def add_to_balance(self, num_credits):
|
|
if self.pledged - self.balance > num_credits : # negative to withdraw
|
|
return False
|
|
else:
|
|
self.balance = self.balance + num_credits
|
|
self.save()
|
|
try: # bad things can happen here if you don't return True
|
|
CreditLog(user = self.user, amount = num_credits, action="add_to_balance").save()
|
|
except:
|
|
logger.exception("failed to log add_to_balance of %s", num_credits)
|
|
try:
|
|
credit_balance_added.send(sender=self, amount=num_credits)
|
|
except:
|
|
logger.exception("credit_balance_added failed of %s", num_credits)
|
|
return True
|
|
|
|
def add_to_pledged(self, num_credits):
|
|
num_credits=Decimal(num_credits)
|
|
if num_credits is Decimal('NaN'):
|
|
return False
|
|
if self.balance - self.pledged < num_credits :
|
|
return False
|
|
else:
|
|
self.pledged=self.pledged + num_credits
|
|
self.save()
|
|
try: # bad things can happen here if you don't return True
|
|
CreditLog(user = self.user, amount = num_credits, action="add_to_pledged").save()
|
|
except:
|
|
logger.exception("failed to log add_to_pledged of %s", num_credits)
|
|
return True
|
|
|
|
def use_pledge(self, num_credits):
|
|
if not isinstance( num_credits, int):
|
|
return False
|
|
if self.pledged < num_credits :
|
|
return False
|
|
else:
|
|
self.pledged=self.pledged - num_credits
|
|
self.balance = self.balance - num_credits
|
|
self.save()
|
|
try:
|
|
CreditLog(user = self.user, amount = - num_credits, action="use_pledge").save()
|
|
except:
|
|
logger.exception("failed to log use_pledge of %s", num_credits)
|
|
return True
|
|
|
|
def transfer_to(self, receiver, num_credits):
|
|
if not isinstance( num_credits, int) or not isinstance( receiver, User):
|
|
return False
|
|
if self.add_to_balance(-num_credits):
|
|
if receiver.credit.add_to_balance(num_credits):
|
|
return True
|
|
else:
|
|
# unwind transfer
|
|
self.add_to_balance(num_credits)
|
|
return False
|
|
else:
|
|
return False
|
|
|
|
class Sent(models.Model):
|
|
'''used by donation view to record donations it has sent'''
|
|
user = models.CharField(max_length=32, null=True)
|
|
amount = models.DecimalField(default=Decimal('0.00'), max_digits=14, decimal_places=2) # max 999,999,999,999.99
|
|
timestamp = models.DateTimeField(auto_now=True)
|
|
|
|
class Account(models.Model):
|
|
"""holds references to accounts at third party payment gateways, especially for representing credit cards"""
|
|
|
|
# the following fields from stripe Customer might be relevant to Account -- we need to pick good selection
|
|
# c.id, c.description, c.email, datetime.fromtimestamp(c.created, tz=utc), c.account_balance, c.delinquent,
|
|
# c.active_card.fingerprint, c.active_card.type, c.active_card.last4, c.active_card.exp_month, c.active_card.exp_year,
|
|
# c.active_card.country
|
|
|
|
# host: the payment processor. Named after the payment module that hosts the payment processing functions
|
|
host = models.CharField(default=PAYMENT_HOST_NONE, max_length=32, null=False)
|
|
account_id = models.CharField(max_length=128, null=True)
|
|
|
|
# card related info
|
|
card_last4 = models.CharField(max_length=4, null=True)
|
|
|
|
# Visa, American Express, MasterCard, Discover, JCB, Diners Club, or Unknown
|
|
card_type = models.CharField(max_length=32, null=True)
|
|
card_exp_month = models.IntegerField(null=True)
|
|
card_exp_year = models.IntegerField(null=True)
|
|
card_fingerprint = models.CharField(max_length=32, null=True)
|
|
card_country = models.CharField(max_length=2, null=True)
|
|
|
|
# creation and last modified timestamps
|
|
date_created = models.DateTimeField(auto_now_add=True)
|
|
date_modified = models.DateTimeField(auto_now=True)
|
|
date_deactivated = models.DateTimeField(null=True)
|
|
|
|
# associated User if any
|
|
user = models.ForeignKey(User, null=True)
|
|
|
|
def deactivate(self):
|
|
"""Don't allow more than one active Account of given host to be associated with a given user"""
|
|
self.date_deactivated = now()
|
|
self.save()
|
|
|
|
# handle any save, updates to a payment.Transaction
|
|
|
|
def handle_transaction_change(sender, instance, created, **kwargs):
|
|
campaign = instance.campaign
|
|
if campaign:
|
|
campaign.update_left()
|
|
return True
|
|
|
|
# handle any deletes of payment.Transaction
|
|
|
|
def handle_transaction_delete(sender, instance, **kwargs):
|
|
campaign = instance.campaign
|
|
if campaign:
|
|
campaign.update_left()
|
|
return True
|
|
|
|
post_save.connect(handle_transaction_change,sender=Transaction)
|
|
post_delete.connect(handle_transaction_delete,sender=Transaction)
|
|
|
|
# handle recharging failed transactions
|
|
|
|
def recharge_failed_transactions(sender, created, instance, **kwargs):
|
|
"""When a new Account is saved, check whether this is the new active account for a user. If so, recharge any
|
|
outstanding failed transactions
|
|
"""
|
|
|
|
# make sure the new account is active
|
|
if instance.date_deactivated is not None:
|
|
return False
|
|
|
|
transactions_to_recharge = instance.user.transaction_set.filter((Q(status=TRANSACTION_STATUS_FAILED) | Q(status=TRANSACTION_STATUS_ERROR)) & Q(campaign__status='SUCCESSFUL')).all()
|
|
|
|
if transactions_to_recharge:
|
|
from regluit.payment.manager import PaymentManager
|
|
pm = PaymentManager()
|
|
for transaction in transactions_to_recharge:
|
|
# check whether we are still within the window to recharge
|
|
if (now() - transaction.campaign.deadline) < datetime.timedelta(settings.RECHARGE_WINDOW):
|
|
logger.info("Recharging transaction {0} w/ status {1}".format(transaction.id, transaction.status))
|
|
pm.execute_transaction(transaction, [])
|
|
|
|
post_save.connect(recharge_failed_transactions, sender=Account)
|
|
|
|
|
|
|
|
|