示例#1
0
def existing_payment_source(existing_customer: Customer,
                            source_token: str) -> Customer:
    """
    If Customer does not have an existing Payment Source and has not been Deleted:
        - Set the Customer's payment source to the new token
        - return the updated Customer
    Else
        - return the provided customer
    :param existing_customer:
    :param source_token:
    :return:
    """
    if not existing_customer.get("sources"):
        if not existing_customer.get("deleted"):
            existing_customer = vendor.modify_customer(
                customer_id=existing_customer["id"],
                source_token=source_token,
                idempotency_key=utils.get_indempotency_key(),
            )
            logger.info("add source", existing_customer=existing_customer)
        else:
            logger.info(
                "stripe customer is marked as deleted. cannot add source.")
    logger.debug("existing payment source",
                 existing_customer=existing_customer)
    return existing_customer
示例#2
0
def existing_payment_source(existing_customer: Customer, source_token: str) -> Customer:
    if not existing_customer.get("sources"):
        if not existing_customer.get("deleted"):
            existing_customer = Customer.modify(
                existing_customer["id"], source=source_token
            )
            logger.info("add source", existing_customer=existing_customer)
        else:
            logger.info("existing source deleted")
    return existing_customer
示例#3
0
def existing_payment_source(existing_customer: Customer,
                            source_token: str) -> Customer:
    if not existing_customer.get("sources"):
        if not existing_customer.get("deleted"):
            existing_customer = vendor.modify_customer(
                customer_id=existing_customer["id"],
                source_token=source_token,
                idempotency_key=utils.get_indempotency_key(),
            )
            logger.info("add source", existing_customer=existing_customer)
        else:
            logger.info("existing source deleted")
    return existing_customer
示例#4
0
def modify_customer(customer_id: str, source_token: str,
                    idempotency_key: str) -> Customer:
    """
    Update customer source
    :param customer_id:
    :param source_token:
    :param idempotency_key:
    :return: updated Customer
    """
    try:
        customer = Customer.modify(customer_id,
                                   source=source_token,
                                   idempotency_key=idempotency_key)
        return customer
    except (
            InvalidRequestError,
            APIConnectionError,
            APIError,
            RateLimitError,
            IdempotencyError,
            CardError,
            StripeErrorWithParamCode,
    ) as e:
        logger.error("modify customer token", error=e)
        raise e
示例#5
0
def create_stripe_customer(source_token: str, email: str, userid: str,
                           name: str, idempotency_key: str) -> Customer:
    """
    Create a new Stripe Customer.
    :param source_token:
    :param email:
    :param userid:
    :param name:
    :param idempotency_key:
    :return: Customer
    """
    try:
        customer = Customer.create(
            source=source_token,
            email=email,
            description=userid,
            name=name,
            metadata={"userid": userid},
            idempotency_key=idempotency_key,
        )
        return customer
    except (
            InvalidRequestError,
            APIConnectionError,
            APIError,
            RateLimitError,
            IdempotencyError,
            CardError,
            StripeErrorWithParamCode,
    ) as e:
        logger.error("create customer error", error=e)
        raise e
示例#6
0
    def token_for_customer(self, token, user):
        """Create a user in Stipe's system using a one time use token
        as returned from `stripe.js`. This function does not alter the user
        object in any way.

        :params token: The one time use token returned by stripe.js when
                            submitting payment details.
        :type token: string
        :param user: The user with which the new stripe customer will be
                    associated, used only for error logging.
        :type user: :class:`pooldlib.postgresql.models.User`

        :returns: string, the Customer ID returned by Stripe.

        :raises: stripe.AuthenticationError
                 stripe.InvalidRequestError
                 stripe.APIConnectionError
                 stripe.APIError
        """
        kwargs = dict(card=token,
                      description='Poold user: %s' % user.id,
                      email=user.email)
        try:
            stripe_user = _Customer.create(api_key=self.api_key, **kwargs)
            msg = 'New Stripe Customer Created'
            logger.transaction(msg, **kwargs)
        except stripe.StripeError, e:
            self._handle_error(e, user, kwargs)
示例#7
0
def stripe():
    print '--- got stripe request ---'
    stripe.api_key = stripe_keys['secret_key']
    form = stripeform()
    output = render_template('stripe.html', key=stripe_keys['publishable_key'], form=form)
    if form.amount.data:
        drill("xTcR Donation","Thanks for donating to xTcR!",request.form["stripeEmail"])
        #stripe.api_key = "sk_test_KBnACrVyXtFPcHyGTd5cot9D"

        customer = Customer.create(
            email= request.form["stripeEmail"],
            card=request.form['stripeToken']
        )

        charge = Charge.create(
            customer=customer.id,
            amount=form.amount.data * 100,
            currency='usd',
            description='xTcR Donation'
        )

        amnt = form.amount.data * 100
        custom = '0'
        if request.form.has_key('custom'):
            custom = str(request.form['custom'])

        cb_data = {
             #'app': 'donate',
             #'do': 'payment',
             #'gateway': '1',
             'mc_gross': float(charge['amount']) / 100,
             'mc_currency': charge['currency'],
             'custom': custom,
             'payment_status': 'Completed' if charge['status'] == 'succeeded' else charge['status'],
             'business': charge['receipt_email'],
             'option_selection1': '',
             'option_selection2': '',
             'txn_id': charge['id'],
             'memo': 'stripe',
             'fees': (float(charge['amount']) / 100) * 0.029 + 0.30,
             'item_name': str(request.form['item_name']),
             'item_number': str(request.form['item_number'])
        }

        r = requests.post("http://192.3.130.131/index.php?app=donate&do=payment&gateway=1", data=cb_data)
        try:
            r = requests.get("http://kc1.freebieservers.com/1/donate.php?name=%s&amount=%s"%(g.user.nickname,amnt))
            print r
            print r.url
        except:
            print "Server Down"

        print ' ----- '
        cmd("echo '%s' >> stripe.log"%r.text)

        output = redirect("http://xtcr.net/success.html")


    return output
示例#8
0
def billing_profile_created_receiver(sender, instance, *args, **kwargs):
    if not instance.customer_id and instance.email:
        # print("ACTUAL API REQUEST Send to Stripe")
        customer = Customer.create(
            email=instance.email
        )
        # print(customer)
        instance.customer_id = customer.id
示例#9
0
def fetch_customer(subhub_account: SubHubAccount, user_id: str) -> Customer:
    customer = None
    db_account = subhub_account.get_user(user_id)
    if db_account:
        customer = Customer.retrieve(db_account.cust_id)
        if "deleted" in customer and customer["deleted"]:
            subhub_account.remove_from_db(user_id)
            customer = None
    return customer
示例#10
0
def update_payment_method(uid, data) -> FlaskResponse:
    """
    Given a user id and a payment token, update user's payment method
    :param uid:
    :param data:
    :return: Success or failure message.
    """
    customer = fetch_customer(g.subhub_account, uid)
    logger.info("customer", customer=customer)
    if not customer:
        return dict(message="Customer does not exist."), 404

    metadata = customer.get("metadata")
    logger.info("metadata", metadata=metadata, customer=type(customer))
    if metadata:
        if metadata["userid"] == uid:
            Customer.modify(customer.id, source=data["pmt_token"])
            return {"message": "Payment method updated successfully."}, 201

    return dict(message="Customer mismatch."), 400
示例#11
0
def get_customer_list(email: str) -> Optional[List[Customer]]:
    try:
        customer_list = Customer.list(email=email)
        return customer_list
    except (
            APIConnectionError,
            APIError,
            RateLimitError,
            StripeErrorWithParamCode,
    ) as e:
        logger.error("get customer list error", error=e)
        raise e
示例#12
0
def has_existing_plan(customer: Customer, plan_id: str) -> bool:
    """
    Check if user has the existing plan in an active or trialing state.
    :param customer:
    :param plan_id:
    :return: True if user has existing plan, otherwise False
    """
    if customer.get("subscriptions"):
        for item in customer["subscriptions"]["data"]:
            if item["plan"]["id"] == plan_id and item["status"] in [
                "active",
                "trialing",
            ]:
                return True
    return False
示例#13
0
 def form_valid(self, form):
     trans = form.cleaned_data["transactionDetails"]
     try:
         stripe_customer = StripeCustomer.retrieve(trans["customer_id"])
         cus = Customer.objects.create(
             user=self.request.user,
             stripe_id=stripe_customer["id"]
         )
         sync_customer(cus, stripe_customer)
         return redirect(reverse("pinax_stripe_subscription_list"))
     except StripeError as e:
         messages.error(self.request, "Unable to communicate with stripe. Please try again later")
         logger.error("Stripe Error during checkout for customer {}".format(
             self.request.user
         ), exc_info=True)
         return redirect(reverse("pinax_stripe_subscription_list"))
示例#14
0
def create_customer(
    subhub_account: SubHubAccount,
    user_id: str,
    email: str,
    source_token: str,
    origin_system: str,
    display_name: str,
) -> Customer:
    _validate_origin_system(origin_system)
    # First search Stripe to ensure we don't have an unlinked Stripe record
    # already in Stripe
    customer = None
    customers = Customer.list(email=email)
    for possible_customer in customers.data:
        if possible_customer.email == email:
            # If the userid doesn't match, the system is damaged.
            if possible_customer.metadata.get("userid") != user_id:
                raise ServerError("customer email exists but userid mismatch")

            customer = possible_customer
            # If we have a mis-match on the source_token, overwrite with the
            # new one.
            if customer.default_source != source_token:
                Customer.modify(customer.id, source=source_token)
            break

    # No existing Stripe customer, create one.
    if not customer:
        try:
            customer = Customer.create(
                source=source_token,
                email=email,
                description=user_id,
                name=display_name,
                metadata={"userid": user_id},
            )

        except InvalidRequestError as e:
            logger.error("create customer error", error=e)
            raise InvalidRequestError(
                message="Unable to create customer.", param=str(e)
            )
    # Link the Stripe customer to the origin system id
    db_account = subhub_account.new_user(
        uid=user_id, origin_system=origin_system, cust_id=customer.id
    )

    if not subhub_account.save_user(db_account):
        # Clean-up the Stripe customer record since we can't link it
        Customer.delete(customer.id)
        e = IntermittentError("error saving db record")
        logger.error("unable to save user or link it", error=e)
        raise e
    return customer
示例#15
0
def delete_customer(uid) -> FlaskResponse:
    """
    Delete an existing customer, cancel active subscriptions
    and delete from payment provider
    :param uid:
    :return: Success of failure message for the deletion
    """
    subscription_user = g.subhub_account.get_user(uid)
    if not subscription_user:
        return dict(message="Customer does not exist."), 404
    deleted_payment_customer = Customer.delete(subscription_user.cust_id)
    if deleted_payment_customer:
        deleted_customer = delete_user_from_db(uid)
        user = g.subhub_account.get_user(uid)
        if deleted_customer and user is None:
            return dict(message="Customer deleted successfully"), 200
    return dict(message="Customer not available"), 400
示例#16
0
def charge():
    if not check_body(["plan", "transaction"]):
        return errors.missing_charge_parameters()

    plan = int(request.json["plan"])
    token = request.json["transaction"]["id"]

    amount = [499, 2748, 4992][plan]

    customer = Customer.create(email=current_user.email, source=token)

    charge = Charge.create(customer=customer.id,
                           amount=amount,
                           currency="usd",
                           description="Flask Charge")

    return "", 204
示例#17
0
def delete_stripe_customer(customer_id: str) -> Dict[str, Any]:
    """
    Delete a Stripe customer
    :param customer_id:
    :return: object
    """
    try:
        deleted_customer = Customer.delete(sid=customer_id)
        return deleted_customer
    except (
            InvalidRequestError,
            APIConnectionError,
            APIError,
            RateLimitError,
            StripeErrorWithParamCode,
    ) as e:
        logger.error("delete customer error", error=e)
        raise e
示例#18
0
def retrieve_stripe_customer(customer_id: str) -> Optional[Customer]:
    """
    Retrieve Stripe Customer
    :param customer_id:
    :return: Customer
    """
    try:
        customer = Customer.retrieve(id=customer_id)
        return customer
    except (
            InvalidRequestError,
            APIConnectionError,
            APIError,
            RateLimitError,
            StripeErrorWithParamCode,
    ) as e:
        logger.error("retrieve stripe customer error", error=e)
        raise e
示例#19
0
def fetch_customer(subhub_account: SubHubAccount, user_id: str) -> Customer:
    customer = None
    db_account = subhub_account.get_user(user_id)
    if db_account:
        customer = Customer.retrieve(db_account.cust_id)
    return customer
示例#20
0
def stripe():
    print '--- got stripe request ---'
    stripe.api_key = stripe_keys['secret_key']
    form = stripeform()
    output = render_template('stripe.html',
                             key=stripe_keys['publishable_key'],
                             form=form)
    if form.amount.data:
        drill("xTcR Donation", "Thanks for donating to xTcR!",
              request.form["stripeEmail"])
        #stripe.api_key = "sk_test_KBnACrVyXtFPcHyGTd5cot9D"

        customer = Customer.create(email=request.form["stripeEmail"],
                                   card=request.form['stripeToken'])

        charge = Charge.create(customer=customer.id,
                               amount=form.amount.data * 100,
                               currency='usd',
                               description='xTcR Donation')

        amnt = form.amount.data * 100
        custom = '0'
        if request.form.has_key('custom'):
            custom = str(request.form['custom'])

        cb_data = {
            #'app': 'donate',
            #'do': 'payment',
            #'gateway': '1',
            'mc_gross':
            float(charge['amount']) / 100,
            'mc_currency':
            charge['currency'],
            'custom':
            custom,
            'payment_status':
            'Completed'
            if charge['status'] == 'succeeded' else charge['status'],
            'business':
            charge['receipt_email'],
            'option_selection1':
            '',
            'option_selection2':
            '',
            'txn_id':
            charge['id'],
            'memo':
            'stripe',
            'fees': (float(charge['amount']) / 100) * 0.029 + 0.30,
            'item_name':
            str(request.form['item_name']),
            'item_number':
            str(request.form['item_number'])
        }

        r = requests.post(
            "http://192.3.130.131/index.php?app=donate&do=payment&gateway=1",
            data=cb_data)
        try:
            r = requests.get(
                "http://kc1.freebieservers.com/1/donate.php?name=%s&amount=%s"
                % (g.user.nickname, amnt))
            print r
            print r.url
        except:
            print "Server Down"

        print ' ----- '
        cmd("echo '%s' >> stripe.log" % r.text)

        output = redirect("http://xtcr.net/success.html")

    return output