dynamicweb/utils/stripe_utils.py

import logging
import re

import stripe
from django.conf import settings

from datacenterlight.models import StripePlan

stripe.api_key = settings.STRIPE_API_PRIVATE_KEY
logger = logging.getLogger(__name__)


def handleStripeError(f):
    def handleProblems(*args, **kwargs):
        response = {
            'paid': False,
            'response_object': None,
            'error': None
        }

        common_message = "Currently it's not possible to make payments."
        try:
            response_object = f(*args, **kwargs)
            response = {
                'response_object': response_object,
                'error': None
            }
            return response
        except stripe.error.CardError as e:
            # Since it's a decline, stripe.error.CardError will be caught
            body = e.json_body
            err = body['error']
            response.update({'error': err['message']})
            logger.error(str(e))
            return response
        except stripe.error.RateLimitError as e:
            logger.error(str(e))
            response.update(
                {'error': "Too many requests made to the API too quickly"})
            return response
        except stripe.error.InvalidRequestError as e:
            logger.error(str(e))
            response.update({'error': str(e._message)})
            return response
        except stripe.error.AuthenticationError as e:
            # Authentication with Stripe's API failed
            # (maybe you changed API keys recently)
            logger.error(str(e))
            response.update({'error': str(e)})
            return response
        except stripe.error.APIConnectionError as e:
            logger.error(str(e))
            response.update({'error': str(e)})
            return response
        except stripe.error.StripeError as e:
            # maybe send email
            logger.error(str(e))
            response.update({'error': str(e)})
            return response
        except Exception as e:
            # maybe send email
            logger.error(str(e))
            response.update({'error': str(e)})
            return response

    return handleProblems


class StripeUtils(object):
    CURRENCY = 'chf'
    INTERVAL = 'month'
    SUCCEEDED_STATUS = 'succeeded'
    RESOURCE_ALREADY_EXISTS_ERROR_CODE = 'resource_already_exists'
    STRIPE_NO_SUCH_PLAN = 'No such plan'
    PLAN_EXISTS_ERROR_MSG = 'Plan {} exists already.\nCreating a local StripePlan now.'
    PLAN_DOES_NOT_EXIST_ERROR_MSG = 'Plan {} does not exist.'

    def __init__(self):
        self.stripe = stripe

    def update_customer_token(self, customer, token):
        customer.source = token
        customer.save()

    @handleStripeError
    def associate_customer_card(self, stripe_customer_id, id_payment_method,
                                set_as_default=False):
        customer = stripe.Customer.retrieve(stripe_customer_id)
        stripe.PaymentMethod.attach(
            id_payment_method,
            customer=stripe_customer_id,
        )
        if set_as_default:
            customer.invoice_settings.default_payment_method = id_payment_method
            customer.save()
        return True

    @handleStripeError
    def dissociate_customer_card(self, stripe_customer_id, card_id):
        customer = stripe.Customer.retrieve(stripe_customer_id)
        if card_id.startswith("pm"):
            logger.debug("PaymentMethod %s detached %s" % (card_id,
                                                           stripe_customer_id))
            pm = stripe.PaymentMethod.retrieve(card_id)
            stripe.PaymentMethod.detach(card_id)
            pm.delete()
        else:
            logger.debug("card %s detached %s" % (card_id, stripe_customer_id))
            card = customer.sources.retrieve(card_id)
            card.delete()

    @handleStripeError
    def update_customer_card(self, customer_id, token):
        customer = stripe.Customer.retrieve(customer_id)
        current_card_token = customer.default_source
        customer.sources.retrieve(current_card_token).delete()
        customer.source = token
        customer.save()
        credit_card_raw_data = customer.sources.data.pop()
        new_card_data = {
            'last4': credit_card_raw_data.last4,
            'brand': credit_card_raw_data.brand
        }
        return new_card_data

    @handleStripeError
    def get_card_details(self, customer_id):
        customer = stripe.Customer.retrieve(customer_id)
        credit_card_raw_data = customer.sources.data.pop()
        card_details = {
            'last4': credit_card_raw_data.last4,
            'brand': credit_card_raw_data.brand,
            'exp_month': credit_card_raw_data.exp_month,
            'exp_year': credit_card_raw_data.exp_year,
            'fingerprint': credit_card_raw_data.fingerprint,
            'card_id': credit_card_raw_data.id
        }
        return card_details

    @handleStripeError
    def get_all_invoices(self, customer_id, created_gt):
        return_list = []
        has_more_invoices = True
        starting_after = False
        while has_more_invoices:
            if starting_after:
                invoices = stripe.Invoice.list(
                    limit=10, customer=customer_id, created={'gt': created_gt},
                    starting_after=starting_after
                )
            else:
                invoices = stripe.Invoice.list(
                    limit=10, customer=customer_id, created={'gt': created_gt}
                )
            has_more_invoices = invoices.has_more
            for invoice in invoices.data:
                sub_ids = []
                for line in invoice.lines.data:
                    if line.type == 'subscription':
                        sub_ids.append(line.id)
                    elif line.type == 'invoiceitem':
                        sub_ids.append(line.subscription)
                    else:
                        sub_ids.append('')
                invoice_details = {
                    'created': invoice.created,
                    'receipt_number': invoice.receipt_number,
                    'invoice_number': invoice.number,
                    'paid_at': invoice.status_transitions.paid_at if invoice.paid else 0,
                    'period_start': invoice.period_start,
                    'period_end': invoice.period_end,
                    'billing_reason': invoice.billing_reason,
                    'discount': invoice.discount.coupon.amount_off if invoice.discount else 0,
                    'total': invoice.total,
                    # to see how many line items we have in this invoice and
                    # then later check if we have more than 1
                    'lines_data_count': len(invoice.lines.data) if invoice.lines.data is not None else 0,
                    'invoice_id': invoice.id,
                    'lines_meta_data_csv': ','.join(
                        [line.metadata.VM_ID if hasattr(line.metadata, 'VM_ID') else '' for line in invoice.lines.data]
                    ),
                    'subscription_ids_csv': ','.join(sub_ids),
                    'line_items': invoice.lines.data
                }
                starting_after = invoice.id
                return_list.append(invoice_details)
        return return_list

    @handleStripeError
    def get_cards_details_from_token(self, token):
        stripe_token = stripe.Token.retrieve(token)
        card_details = {
            'last4': stripe_token.card.last4,
            'brand': stripe_token.card.brand,
            'exp_month': stripe_token.card.exp_month,
            'exp_year': stripe_token.card.exp_year,
            'fingerprint': stripe_token.card.fingerprint,
            'card_id': stripe_token.card.id
        }
        return card_details

    @handleStripeError
    def get_cards_details_from_payment_method(self, payment_method_id):
        payment_method = stripe.PaymentMethod.retrieve(payment_method_id)
        # payment_method does not always seem to have a card with id
        # if that is the case, fallback to payment_method_id for card_id
        card_id = payment_method_id
        if hasattr(payment_method.card, 'id'):
            card_id = payment_method.card.id
        card_details = {
            'last4': payment_method.card.last4,
            'brand': payment_method.card.brand,
            'exp_month': payment_method.card.exp_month,
            'exp_year': payment_method.card.exp_year,
            'fingerprint': payment_method.card.fingerprint,
            'card_id': card_id
        }
        return card_details

    def check_customer(self, stripe_cus_api_id, user, token):
        try:
            customer = stripe.Customer.retrieve(stripe_cus_api_id)
        except stripe.InvalidRequestError:
            customer = self.create_customer(token, user.email, user.name)
            user.stripecustomer.stripe_id = customer.get(
                'response_object').get('id')
            user.stripecustomer.save()
        if type(customer) is dict:
            customer = customer['response_object']
        return customer

    @handleStripeError
    def get_customer(self, stripe_api_cus_id):
        customer = stripe.Customer.retrieve(stripe_api_cus_id)
        # data = customer.get('response_object')
        return customer

    @handleStripeError
    def create_customer(self, id_payment_method, email, name=None):
        if name is None or name.strip() == "":
            name = email
        customer = self.stripe.Customer.create(
            payment_method=id_payment_method,
            description=name,
            email=email
        )
        return customer

    @handleStripeError
    def make_charge(self, amount=None, customer=None):
        _amount = float(amount)
        amount = int(_amount * 100)  # stripe amount unit, in cents
        charge = self.stripe.Charge.create(
            amount=amount,  # in cents
            currency=self.CURRENCY,
            customer=customer
        )
        return charge

    @handleStripeError
    def get_or_create_stripe_plan(self, amount, name, stripe_plan_id,
                                  interval=""):
        """
        This function checks if a StripePlan with the given
        stripe_plan_id already exists. If it exists then the function
        returns this object otherwise it creates a new StripePlan and
        returns the new object.

        :param amount: The amount in CHF
        :param name: The name of the Stripe plan to be created.
        :param stripe_plan_id: The id of the Stripe plan to be
               created. Use get_stripe_plan_id_string function to
               obtain the name of the plan to be created
        :param interval: str representing the interval of the Plan
               Specifies billing frequency. Either day, week, month or year.
               Ref: https://stripe.com/docs/api/plans/create#create_plan-interval
               The default is month
        :return: The StripePlan object if it exists else creates a
               Plan object in Stripe and a local StripePlan and
               returns it. Returns None in case of Stripe error
        """
        _amount = float(amount)
        amount = int(_amount * 100)  # stripe amount unit, in cents
        stripe_plan_db_obj = None
        plan_interval = interval if interval is not "" else self.INTERVAL
        try:
            stripe_plan_db_obj = StripePlan.objects.get(
                stripe_plan_id=stripe_plan_id)
        except StripePlan.DoesNotExist:
            try:
                self.stripe.Plan.create(
                    amount=amount,
                    interval=plan_interval,
                    name=name,
                    currency=self.CURRENCY,
                    id=stripe_plan_id)
                stripe_plan_db_obj = StripePlan.objects.create(
                    stripe_plan_id=stripe_plan_id)
            except stripe.error.InvalidRequestError as e:
                logger.error(str(e))
                logger.error("error_code = %s" % str(e.__dict__))
                if self.RESOURCE_ALREADY_EXISTS_ERROR_CODE in e.error.code:
                    logger.debug(
                        self.PLAN_EXISTS_ERROR_MSG.format(stripe_plan_id))
                    stripe_plan_db_obj, c = StripePlan.objects.get_or_create(
                        stripe_plan_id=stripe_plan_id)
                    if c:
                        logger.debug("Created stripe plan %s" % stripe_plan_id)
                    else:
                        logger.debug("Plan %s exists already" % stripe_plan_id)
        return stripe_plan_db_obj

    @handleStripeError
    def delete_stripe_plan(self, stripe_plan_id):
        """
        Deletes the Plan in Stripe and also deletes the local db copy
        of the plan if it exists

        :param stripe_plan_id: The stripe plan id that needs to be
               deleted
        :return: True if the plan was deleted successfully from
               Stripe, False otherwise.
        """
        return_value = False
        try:
            plan = self.stripe.Plan.retrieve(stripe_plan_id)
            plan.delete()
            return_value = True
            StripePlan.objects.filter(
                stripe_plan_id=stripe_plan_id).all().delete()
        except stripe.error.InvalidRequestError as e:
            if self.STRIPE_NO_SUCH_PLAN in str(e):
                logger.debug(
                    self.PLAN_DOES_NOT_EXIST_ERROR_MSG.format(stripe_plan_id))
        return return_value

    @handleStripeError
    def subscribe_customer_to_plan(self, customer, plans, trial_end=None,
                                   coupon="", tax_rates=list(),
                                   default_payment_method=""):
        """
        Subscribes the given customer to the list of given plans

        :param default_payment_method:
        :param tax_rates:
        :param coupon:
        :param customer: The stripe customer identifier
        :param plans: A list of stripe plans.
        :param trial_end: An integer representing when the Stripe subscription
               is supposed to end
        Ref: https://stripe.com/docs/api/python#create_subscription-items
              e.g.
                    plans = [
                                {
                                  "plan": "dcl-v1-cpu-2-ram-5gb-ssd-10gb",
                                },
                            ]
        :return: The subscription StripeObject
        """
        logger.debug("Subscribing %s to plan %s : coupon = %s" % (
            customer, str(plans), str(coupon)
        ))
        subscription_result = self.stripe.Subscription.create(
            customer=customer, items=plans, trial_end=trial_end,
            coupon=coupon,
            default_tax_rates=tax_rates,
            payment_behavior='allow_incomplete',
            default_payment_method=default_payment_method
        )
        logger.debug("Done subscribing")
        return subscription_result

    @handleStripeError
    def set_subscription_metadata(self, subscription_id, metadata):
        subscription = stripe.Subscription.retrieve(subscription_id)
        subscription.metadata = metadata
        subscription.save()

    @handleStripeError
    def unsubscribe_customer(self, subscription_id):
        """
        Cancels a given subscription

        :param subscription_id: The Stripe subscription id string
        :return:
        """
        sub = stripe.Subscription.retrieve(subscription_id)
        return sub.delete()

    @handleStripeError
    def make_payment(self, customer, amount, token):
        charge = self.stripe.Charge.create(
            amount=amount,  # in cents
            currency=self.CURRENCY,
            customer=customer
        )
        return charge

    @staticmethod
    def get_stripe_plan_id(cpu, ram, ssd, version, app='dcl', hdd=None,
                           price=None, excl_vat=True):
        """
        Returns the Stripe plan id string of the form
        `dcl-v1-cpu-2-ram-5gb-ssd-10gb` based on the input parameters

        :param cpu: The number of cores
        :param ram: The size of the RAM in GB
        :param ssd: The size of ssd storage in GB
        :param hdd: The size of hdd storage in GB
        :param version: The version of the Stripe plans
        :param app: The application to which the stripe plan belongs
        to. By default it is 'dcl'
        :param price: The price for this plan
        :return: A string of the form `dcl-v1-cpu-2-ram-5gb-ssd-10gb`
        """
        dcl_plan_string = 'cpu-{cpu}-ram-{ram}gb-ssd-{ssd}gb'.format(cpu=cpu,
                                                                     ram=ram,
                                                                     ssd=ssd)
        if hdd is not None:
            dcl_plan_string = '{dcl_plan_string}-hdd-{hdd}gb'.format(
                dcl_plan_string=dcl_plan_string, hdd=hdd)
        stripe_plan_id_string = '{app}-v{version}-{plan}'.format(
            app=app,
            version=version,
            plan=dcl_plan_string
        )
        if price is not None:
            stripe_plan_id_string = '{}-{}chf'.format(
                stripe_plan_id_string,
                round(price, 2)
            )
        if excl_vat:
            stripe_plan_id_string = '{}-{}'.format(
                stripe_plan_id_string,
                "excl_vat"
            )
        return stripe_plan_id_string

    @staticmethod
    def get_vm_config_from_stripe_id(stripe_id):
        """
        Given a string like "dcl-v1-cpu-2-ram-5gb-ssd-10gb" return different
        configuration params as a dict

        :param stripe_id|str
        :return: dict
        """
        pattern = re.compile(r'^dcl-v(\d+)-cpu-(\d+)-ram-(\d+\.?\d*)gb-ssd-(\d+)gb-?(\d*\.?\d*)(chf)?$')
        match_res = pattern.match(stripe_id)
        if match_res is not None:
            price = None
            try:
                price=match_res.group(5)
            except IndexError as ie:
                logger.debug("Did not find price in {}".format(stripe_id))
            return {
                'version': match_res.group(1),
                'cores': match_res.group(2),
                'ram': match_res.group(3),
                'ssd': match_res.group(4),
                'price': price
            }


    @staticmethod
    def get_stripe_plan_name(cpu, memory, disk_size, price, excl_vat=True):
        """
        Returns the Stripe plan name
        :return:
        """
        if excl_vat:
            return "{cpu} Cores, {memory} GB RAM, {disk_size} GB SSD, " \
                   "{price} CHF Excl. VAT".format(
                cpu=cpu,
                memory=memory,
                disk_size=disk_size,
                price=round(price, 2)
            )
        else:
            return "{cpu} Cores, {memory} GB RAM, {disk_size} GB SSD, " \
                   "{price} CHF".format(
                        cpu=cpu,
                        memory=memory,
                        disk_size=disk_size,
                        price=round(price, 2)
                    )

    @handleStripeError
    def set_subscription_meta_data(self, subscription_id, meta_data):
        """
        Adds VM metadata to a subscription
        :param subscription_id: Stripe identifier for the subscription
        :param meta_data: A dict of meta data to be added
        :return:
        """
        subscription = stripe.Subscription.retrieve(subscription_id)
        subscription.metadata = meta_data
        subscription.save()

    @handleStripeError
    def get_or_create_tax_id_for_user(self, stripe_customer_id, vat_number,
                                      type="eu_vat", country=""):
        tax_ids_list = stripe.Customer.list_tax_ids(
            stripe_customer_id,
            limit=100,
        )
        for tax_id_obj in tax_ids_list.data:
            if self.compare_vat_numbers(tax_id_obj.value, vat_number):
                logger.debug("tax id obj exists already")
                return tax_id_obj
            else:
                logger.debug(
                    "{val1} is not equal to {val2} or {con1} not same as "
                    "{con2}".format(val1=tax_id_obj.value, val2=vat_number,
                                    con1=tax_id_obj.country.lower(),
                                    con2=country.lower().strip()))
        logger.debug(
            "tax id obj does not exist for {val}. Creating a new one".format(
                val=vat_number
            ))
        tax_id_obj = stripe.Customer.create_tax_id(
            stripe_customer_id,
            type=type,
            value=vat_number,
        )
        return tax_id_obj

    @handleStripeError
    def get_payment_intent(self, amount, customer):
        """	Create a stripe PaymentIntent of the given amount and return it
            :param amount: the amount of payment_intent
            :return:
        """
        payment_intent_obj = stripe.PaymentIntent.create(
            amount=amount,
            currency='chf',
            customer=customer,
            setup_future_usage='off_session'
        )
        return payment_intent_obj

    @handleStripeError
    def get_available_payment_methods(self, customer):
        """	Retrieves all payment methods of the given customer
            :param customer: StripeCustomer object
            :return: a list of available payment methods
        """
        return_list = []
        if customer is None:
            return return_list
        cu = stripe.Customer.retrieve(customer.stripe_id)
        pms = stripe.PaymentMethod.list(
            customer=customer.stripe_id,
            type="card",
        )
        default_source = None
        if cu.default_source:
            default_source = cu.default_source
        else:
            default_source = cu.invoice_settings.default_payment_method
        for pm in pms.data:
            return_list.append({
                'last4': pm.card.last4, 'brand': pm.card.brand, 'id': pm.id,
                'exp_year': pm.card.exp_year,
                'exp_month': '{:02d}'.format(pm.card.exp_month),
                'preferred': pm.id == default_source
            })
        return return_list

    def compare_vat_numbers(self, vat1, vat2):
        _vat1 = vat1.replace(" ", "").replace(".", "").replace("-","")
        _vat2 = vat2.replace(" ", "").replace(".", "").replace("-","")
        return True if _vat1 == _vat2 else False