def create_from_card_token(self, card_token, user, environment=None):
"""
Create a new CustomerToken from a card_token and attaches a
CardToken to the CustomerToken instance.
"""
CardToken = get_model('pinpayments', 'CardToken')
CustomerToken = self.model
pin_env = PinEnvironment(environment)
payload = {'email': user.email, 'card_token': card_token}
data = pin_env.pin_post("/customers", payload)[1]['response']
customer = CustomerToken.objects.create(
user=user,
token=data['token'],
environment=environment,
)
# attach the card object
card = CardToken.objects.create_from_data(data.get('card'))
customer.cards.add(card)
if card.primary:
self.set_primary_card_models(customer, card)
return customer
def create_from_card_token(self, card_token, user, environment=None):
"""
Create a new CustomerToken from a card_token and attaches a
CardToken to the CustomerToken instance.
"""
CardToken = get_model('pinpayments', 'CardToken')
CustomerToken = self.model
pin_env = PinEnvironment(environment)
payload = {'email': user.email, 'card_token': card_token}
data = pin_env.pin_post("/customers", payload)[1]['response']
customer = CustomerToken.objects.create(
user=user,
token=data['token'],
environment=environment,
)
# attach the card object
card = CardToken.objects.create_from_data(data.get('card'))
customer.cards.add(card)
if card.primary:
self.set_primary_card_models(customer, card)
return customer
def create_with_bank_account(cls,
email,
account_name,
bsb,
number,
name=""):
""" Creates a new recipient from a provided bank account's details """
pin_env = PinEnvironment()
payload = {
'email': email,
'name': name,
'bank_account[name]': account_name,
'bank_account[bsb]': bsb,
'bank_account[number]': number
}
data = pin_env.pin_post('/recipients', payload)[1]['response']
bank_account = BankAccount.objects.create(
bank_name=data['bank_account']['bank_name'],
branch=data['bank_account']['branch'],
bsb=data['bank_account']['bsb'],
name=data['bank_account']['name'],
number=data['bank_account']['number'],
token=data['bank_account']['token'],
environment=pin_env.name,
)
new_recipient = cls.objects.create(
token=data['token'],
email=data['email'],
name=data['name'],
bank_account=bank_account,
environment=pin_env.name,
)
return new_recipient
def update_card(self, card_token):
""" Provide a card token to update the details for this customer """
pin_env = PinEnvironment(self.environment)
payload = {'card_token': card_token}
url_tail = "/customers/{1}".format(self.token)
data = pin_env.pin_put(url_tail, payload)[1]['response']
self.card_number = data['card']['display_number']
self.card_type = data['card']['scheme']
self.card_name = data['card']['name']
self.save()
def process_transaction(self):
""" Send the data to Pin for processing """
if self.processed:
return None # can only attempt to process once.
self.processed = True
self.save()
pin_env = PinEnvironment(self.environment)
payload = {
'email': self.email_address,
'description': self.description,
'amount': int(self.amount * 100),
'currency': self.currency,
'ip_address': self.ip_address,
}
if self.card_token:
payload['card_token'] = self.card_token
else:
payload['customer_token'] = self.customer_token.token
response, response_json = pin_env.pin_post('/charges', payload, True)
self.pin_response_text = response.text
if response_json is None:
self.pin_response = 'Failure.'
elif 'error' in response_json.keys():
if 'messages' in response_json.keys():
if 'message' in response_json['messages'][0].keys():
self.pin_response = 'Failure: {0}'.format(
response_json['messages'][0]['message']
)
else:
self.pin_response = 'Failure: {0}'.format(
response_json['error_description']
)
self.transaction_token = response_json.get('charge_token', None)
else:
data = response_json['response']
self.succeeded = True
self.transaction_token = data['token']
self.fees = data['total_fees'] / Decimal("100.00")
self.pin_response = data['status_message']
self.card_address1 = data['card']['address_line1']
self.card_address2 = data['card']['address_line2']
self.card_city = data['card']['address_city']
self.card_state = data['card']['address_state']
self.card_postcode = data['card']['address_postcode']
self.card_country = data['card']['address_country']
self.card_number = data['card']['display_number']
self.card_type = data['card']['scheme']
self.save()
return self.pin_response
def set_primary_card_for_customer(self, customer, card):
"""
Sets the primary CardToken for a given CustomerToken.
"""
payload = {}
payload.update({
'primary_card_token': card.token,
})
pin_env = PinEnvironment(customer.environment)
url_tail = "/customers/{0}".format(customer.token)
data = pin_env.pin_put(url_tail, payload)[1]['response']
return self.set_primary_card_models(customer, card, data.get('card'))
def set_primary_card_for_customer(self, customer, card):
"""
Sets the primary CardToken for a given CustomerToken.
"""
payload = {}
payload.update({
'primary_card_token': card.token,
})
pin_env = PinEnvironment(customer.environment)
url_tail = "/customers/{0}".format(customer.token)
data = pin_env.pin_put(url_tail, payload)[1]['response']
return self.set_primary_card_models(customer, card, data.get('card'))
def delete_card_from_customer(self, customer, card):
"""
Deletes a CardToken from a CustomerToken instance.
"""
pin_env = PinEnvironment(customer.environment)
if card not in customer.cards.all():
raise PinError("The CardToken does not belong to the CustomerToken and cannot be deleted.")
url_tail = "/customers/{0}/cards/{1}".format(customer.token, card.token)
data = pin_env.pin_delete(url_tail, {}, process_response_body=False)
# success
customer.cards.remove(card)
card.delete()
return True
def delete_card_from_customer(self, customer, card):
"""
Deletes a CardToken from a CustomerToken instance.
"""
pin_env = PinEnvironment(customer.environment)
if card not in customer.cards.all():
raise PinError(
"The CardToken does not belong to the CustomerToken and cannot be deleted."
)
url_tail = "/customers/{0}/cards/{1}".format(customer.token,
card.token)
data = pin_env.pin_delete(url_tail, {}, process_response_body=False)
# success
customer.cards.remove(card)
card.delete()
return True
def send_new(cls, amount, description, recipient, currency="AUD"):
""" Creates a transfer by sending it to Pin """
pin_env = PinEnvironment()
payload = {
'amount': amount,
'description': description,
'recipient': recipient.token,
'currency': currency,
}
response, response_json = pin_env.pin_post('/transfers', payload)
data = response_json['response']
new_transfer = PinTransfer.objects.create(
transfer_token=data['token'],
status=data['status'],
currency=data['currency'],
description=data['description'],
amount=data['amount'],
recipient=recipient,
pin_response_text=response.text,
)
return new_transfer
def add_card_token_to_customer(self, customer, card_token):
"""
Creates a new CardToken instance from a card_token and attaches it to a customer's cards.
"""
CardToken = get_model('pinpayments', 'CardToken')
pin_env = PinEnvironment(customer.environment)
payload = {'card_token': card_token}
url_tail = "/customers/{0}/cards".format(customer.token)
data = pin_env.pin_post(url_tail, payload)[1]['response']
data['environment'] = customer.environment
if customer.cards.filter(token=card_token).exists():
card = customer.cards.get(token=card_token)
# update the card fields
CardToken.objects.update_card_from_data(card, data)
else:
card = CardToken.objects.create_from_data(data)
customer.cards.add(card)
if card.primary:
self.set_primary_card_models(customer, card)
return card
def add_card_token_to_customer(self, customer, card_token):
"""
Creates a new CardToken instance from a card_token and attaches it to a customer's cards.
"""
CardToken = get_model('pinpayments', 'CardToken')
pin_env = PinEnvironment(customer.environment)
payload = {'card_token': card_token}
url_tail = "/customers/{0}/cards".format(customer.token)
data = pin_env.pin_post(url_tail, payload)[1]['response']
data['environment'] = customer.environment
if customer.cards.filter(token=card_token).exists():
card = customer.cards.get(token=card_token)
# update the card fields
CardToken.objects.update_card_from_data(card, data)
else:
card = CardToken.objects.create_from_data(data)
customer.cards.add(card)
if card.primary:
self.set_primary_card_models(customer, card)
return card