stripe-payments
Stripe.Net Einführung

Syntax

• var stripeSubscriptionOptions = new StripeSubscriptionCreateOptions ();

  // Eine Variable erstellen, die das Optionsobjekt enthält

          stripeSubscriptionOptions.Quantity = model.update;
  

  // Beispiel für die Anzahl der Plätze für ein Abonnement

          var subscriptionService = new StripeSubscriptionService();
  

  // einen Dienst erstellen, um den API-Aufruf auszuführen

          var stripeSubscription = subscriptionService.Create(user.CustomerIdentifier, planId,
  

  stripeSubscriptionOptions);

  // service.create (String CustID, String PlanID, Object SubscriptionOptions)

  // Die Kunden-ID sollte in Ihrer Datenbank gespeichert werden. Sie können die Plan-ID mit einem PlanService von Stripe abrufen und das Optionsobjekt wie oben erstellen. Wenn Sie die Stripe.Net-Software von NuGet verwenden, funktioniert Intellisense auch für diese.

Bemerkungen

StripeConfiguration.SetApiKey(YOUR SECRET KEY VAR);

Beginnen mit Stripe.Net in ASP.Net Core 1.0

https://github.com/jaymedavis/stripe.net ist ein guter Ausgangspunkt.
Angenommen, Sie verwenden MVC w / Razor und benötigen einige Dinge auf Ihrer Ansichtsseite

<script type="text/javascript" src="https://js.stripe.com/v2/"></script>

Dieses Skript ruft die stripe.js auf, um die Erstellung eines Tokens zu handhaben.

<script type="text/javascript">
        Stripe.setPublishableKey('YOUR STRIPE PUBLIC KEY');

var stripeResponseHandler = function (status, response) {
    var $form = $('#payment-form');

    if (response.error) {
        // Show the errors on the form
        $form.find('.payment-errors').text(response.error.message);
        $form.find('button').prop('disabled', false);
    } else {
        // token contains id, last4, and card type
        var token = response.id;
        // Insert the token into the form so it gets submitted to the server
        $form.append($('<input type="hidden" asp-for="stripeToken" />').val(token));
        // and re-submit
        $form.get(0).submit();
    }
};

jQuery(function ($) {
    $('#payment-form').submit(function (e) {
        var $form = $(this);

        // Disable the submit button to prevent repeated clicks
        $form.find('button').prop('disabled', true);

        Stripe.card.createToken($form, stripeResponseHandler);

        // Prevent the form from submitting with the default action
        return false;
    });
});
</script>

Um das Token einem Modell hinzuzufügen, stellen Sie sicher, dass Sie es ändern

$form.append($('<input type="hidden" asp-for="stripeToken" />').val(token));

um dein Modell zu reflektieren. Das Formular sollte wie folgt aussehen.

 <form asp-action="confirm" method="POST" id="payment-form">
            <span class="payment-errors"></span>

            <div class="row">
                <label>
                    <span>Card Number</span>
                    <input type="text" data-stripe="number" value="4242424242424242">
                </label>
            </div>

            <div class="row">
                <label>
                    <span>CVC</span>
                    <input type="text" data-stripe="cvc" value="123">
                </label>
            </div>

            <div class="row">
                <label>
                    <span>Expiration (MM/YYYY)</span>
                    <input type="text" data-stripe="exp-month" value="12">
                </label>
                <input type="text" data-stripe="exp-year" value="2020">
            </div>

            <button type="submit">Buy Now</button>
        </form> 

Der Controller nimmt einen der Benutzer und sucht nach einem CustomerIdentifier, der die ID des Kunden ist, die durch Stripe angegeben wird. Wenn dies nicht in der Datenbank gespeichert ist, erstellen Sie einen Kunden für sie

 public async Task<IActionResult> Index(OrderViewModel model)   //HOME PAGE beginning of managing subs
    {
        //get the user and their ID
        var user = await GetCurrentUserAsync();
        var userId = user?.Id;
        // If they have a customer Identifier use it
        if (!string.IsNullOrEmpty(user.CustomerIdentifier))  //eventually if user has a saved card as well
        {
            //Create the API call to subscription and put its response in a list
            var subscriptionService = new StripeSubscriptionService();
            IEnumerable<StripeSubscription> response = subscriptionService.List(user.CustomerIdentifier);

            ViewBag.Subscription = response;

            ViewBag.Customer = user.CustomerIdentifier;


        }
        ModelState.Clear();
        return View(model);
    }
 public async Task<IActionResult> Confirm(OrderViewModel model, string stripeToken)  // CREATE CHARGE NO CARD/ NO CUSTOMER
    {
        model.stripeToken = stripeToken;
        //get the user and their ID
        var user = await GetCurrentUserAsync();
        var userId = user?.Id;
        var planId = "YOUR PLAN ID HERE";  //plan ID only 1 atm but will need to be a dynamic plan ID list later
        // If they have a customer Identifier use it
        if (!string.IsNullOrEmpty(user.CustomerIdentifier))
        {
            //Create the API call to subscription and put its response in a list
            //Use the subscription options to apply a quantity to the initial subscription for seats
            var stripeSubscriptionOptions = new StripeSubscriptionCreateOptions();
            stripeSubscriptionOptions.Quantity = model.update;
            var subscriptionService = new StripeSubscriptionService();
            var stripeSubscription = subscriptionService.Create(user.CustomerIdentifier, planId, stripeSubscriptionOptions);
            //save Subscriptions data here

            ModelState.Clear();
            //await SaveSubscription(stripeSubscription, user);
            await _userManager.UpdateAsync(user);
        }
        else // Customer is new and doesn't have an ID
        {
            //Create API options
            var customer = new StripeCustomerCreateOptions();
            
            // Add option values
            customer.Email = $"{user.Email}";
            customer.Description = $"{user.Email} [{userId}]";
            customer.PlanId = planId;
            
            customer.SourceToken = model.stripeToken;
            //Make the call to create the customer with the creation options
            var customerService = new StripeCustomerService();
            StripeCustomer stripeCustomer = customerService.Create(customer);

            //save the customer ID
            user.CustomerIdentifier = stripeCustomer.Id;

            //create card update options and add billing info
            var cardOptions = new StripeCardUpdateOptions();
            cardOptions.AddressLine1 = model.BillingInfo.AddressL1;
            cardOptions.AddressLine2 = model.BillingInfo.AddressL2;
            cardOptions.AddressCountry = model.BillingInfo.Country;
            cardOptions.AddressCity = model.BillingInfo.City;
            cardOptions.AddressState = model.BillingInfo.State;
            cardOptions.AddressZip = model.BillingInfo.Zip;
            cardOptions.Name = model.BillingInfo.Name;
            var cardUpdate = new StripeCardService();
            // get the customer card ID and then update the card info
            StripeCustomer customerCardGet = customerService.Get(user.CustomerIdentifier);
            var cardId = customerCardGet.DefaultSourceId;
            StripeCard Card = cardUpdate.Update(user.CustomerIdentifier, cardId, cardOptions);


            //save Subscriptions data here
            //user.ConcurrentUsers = Stripe Quantity
            
            ModelState.Clear();

            await _userManager.UpdateAsync(user);
           
        }
        ViewBag.Success = "confirm";
        return View("Success");
    }

Dieses spezielle Beispiel enthält einige der Extras, wie das Erfassen von Rechnungsinformationen in der Steuerung. Wenn Sie dies möchten, fügen Sie es einfach dem Formular in der Ansicht hinzu und erstellen Sie ein Modell, um es zu speichern.