Sindika.AspNet.Midtrans 1.1.1

Sindika.AspNet.Midtrans

A .NET library for integrating Midtrans payment gateway (Snap, Core API, and Iris) into ASP.NET Core applications. This package provides typed HTTP clients, middleware for webhook handling with automatic signature validation, and comprehensive support for Midtrans payment flows.

Features

• ✅ Snap API - Create payment tokens and redirect URLs
• ✅ Core API - Direct charge, transaction status, refund, cancel
• ✅ Iris API - Disbursement and payout operations
• ✅ Webhook Handler - Automatic signature validation and model binding
• ✅ Middleware - Request buffering and logging for notifications
• ✅ Options Pattern - Easy configuration with sandbox/production toggle
• ✅ Typed Clients - Strongly-typed models for all API operations

Installation

Install via NuGet Package Manager:

dotnet add package Sindika.AspNet.Midtrans

Or via Package Manager Console:

Install-Package Sindika.AspNet.Midtrans

Quick Start

1. Configure Services

Add Midtrans configuration to appsettings.json:

{
  "Midtrans": {
    "ServerKey": "SB-Mid-server-xxxxxx",
    "ClientKey": "SB-Mid-client-xxxxxx",
    "IsProduction": false
  }
}

Register services in Program.cs:

using Sindika.AspNet.Midtrans.Core.Extensions;
using Sindika.AspNet.Midtrans.AspNetCore.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Register Midtrans services
builder.Services.AddMidtrans(options =>
{
    builder.Configuration.GetSection("Midtrans").Bind(options);
});

// Add controllers with Midtrans model binders
builder.Services.AddControllers().AddMidtrans();

var app = builder.Build();

// Enable Midtrans notification middleware
app.UseMidtransNotifications();
app.MapControllers();

app.Run();

2. Create Payment

using Sindika.AspNet.Midtrans.Core.Contracts;
using Sindika.AspNet.Midtrans.Core.Models.Request.Snap;
using Sindika.AspNet.Midtrans.Core.Models.Common;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/payment")]
public class PaymentController : ControllerBase
{
    private readonly IMidtransClient _midtrans;

    public PaymentController(IMidtransClient midtrans)
    {
        _midtrans = midtrans;
    }

    [HttpPost]
    public async Task<IActionResult> CreatePayment([FromBody] PaymentRequest request)
    {
        var snapRequest = new SnapTransactionRequest
        {
            TransactionDetails = new TransactionDetails
            {
                OrderId = $"ORDER-{Guid.NewGuid():N}",
                GrossAmount = request.Amount
            },
            CustomerDetails = new CustomerDetails
            {
                Email = request.Email,
                FirstName = request.Name
            }
        };

        var response = await _midtrans.Snap.CreateTransactionAsync(snapRequest);
        
        return Ok(new 
        { 
            token = response.Token,
            redirectUrl = response.RedirectUrl 
        });
    }
}

3. Handle Webhook Notifications

using Sindika.AspNet.Midtrans.AspNetCore.Filters;
using Sindika.AspNet.Midtrans.AspNetCore.ModelBinders;
using Sindika.AspNet.Midtrans.Core.Models.Notification;
using Sindika.AspNet.Midtrans.Core.Enums;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/webhooks/midtrans")]
public class WebhookController : ControllerBase
{
    private readonly ILogger<WebhookController> _logger;

    public WebhookController(ILogger<WebhookController> logger)
    {
        _logger = logger;
    }

    [HttpPost]
    [ValidateMidtransSignature]
    public IActionResult Handle(
        [ModelBinder(BinderType = typeof(MidtransNotificationBinder))] 
        MidtransNotification notification)
    {
        // Update order status in your database
        switch (notification.TransactionStatus)
        {
            case TransactionStatus.Settlement:
                _logger.LogInformation("Payment successful for order {OrderId}", notification.OrderId);
                // Mark order as paid
                break;
            case TransactionStatus.Pending:
                _logger.LogInformation("Payment pending for order {OrderId}", notification.OrderId);
                break;
            case TransactionStatus.Deny:
            case TransactionStatus.Cancel:
            case TransactionStatus.Expire:
                _logger.LogWarning("Payment failed for order {OrderId}", notification.OrderId);
                // Mark order as failed/cancelled
                break;
        }

        return Ok();
    }
}

Advanced Usage

Core API - Direct Charge

var chargeRequest = new ChargeRequest
{
    PaymentType = PaymentType.CreditCard,
    TransactionDetails = new TransactionDetails
    {
        OrderId = "ORDER-123",
        GrossAmount = 150000
    },
    CreditCard = new CreditCardChargeRequest
    {
        Card = new CreditCardDetails
        {
            TokenId = "token-from-frontend"
        }
    }
};

var response = await _midtrans.CoreApi.ChargeAsync(chargeRequest);

Check Transaction Status

var status = await _midtrans.CoreApi.GetTransactionStatusAsync("ORDER-123");
Console.WriteLine($"Status: {status.TransactionStatus}");

Refund Transaction

var refundRequest = new RefundRequest
{
    Amount = 150000,
    Reason = "Customer request"
};

await _midtrans.CoreApi.RefundAsync("ORDER-123", refundRequest);

Configuration Options

Testing with ngrok

For local webhook testing:

ngrok http 5000

Set the ngrok HTTPS URL as your notification URL in Midtrans dashboard:

https://xxxx-xx-xx-xx-xx.ngrok-free.app/api/webhooks/midtrans

Documentation

• Midtrans Official Documentation
• Snap API Reference
• Core API Reference

License

MIT License - see LICENSE file for details.