Braintree .NET SDK

To process a transaction, initialize a BraintreeGateway with your credentials and environment, then use the gateway.Transaction.Sale method with a TransactionRequest.

Key steps in the workflow:

1. Initialize the Gateway: Set the Environment (e.g., Braintree.Environment.SANDBOX), MerchantId, PublicKey, and PrivateKey.
2. Construct the Request: Create a TransactionRequest specifying the Amount, the PaymentMethodNonce (received from the client), and optional TransactionOptionsRequest (like SubmitForSettlement).
3. Execute the Sale: Call gateway.Transaction.Sale(request).
4. Handle the Result: Use result.IsSuccess() to check the outcome.
   • If successful, access the transaction via result.Target.
   • If it fails due to a processor error, check result.Transaction for status and error codes.
   • If it fails due to validation errors, iterate through result.Errors.DeepAll() to inspect Attribute, Code, and Message.

using System;
using Braintree;

namespace BraintreeExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var gateway = new BraintreeGateway
            {
                Environment = Braintree.Environment.SANDBOX,
                MerchantId = "the_merchant_id",
                PublicKey = "a_public_key",
                PrivateKey = "a_private_key"
            };

            TransactionRequest request = new TransactionRequest
            {
                Amount = 1000.00M,
                PaymentMethodNonce = nonceFromTheClient,
                Options = new TransactionOptionsRequest
                {
                    SubmitForSettlement = true
                }
            };

            Result<Transaction> result = gateway.Transaction.Sale(request);

            if (result.IsSuccess())
            {
                Transaction transaction = result.Target;
                Console.WriteLine("Success!: " + transaction.Id);
            }
            else if (result.Transaction != null)
            {
                Transaction transaction = result.Transaction;
                Console.WriteLine("Error processing transaction:");
                Console.WriteLine("  Status: " + transaction.Status);
                Console.WriteLine("  Code: " + transaction.ProcessorResponseCode);
                Console.WriteLine("  Text: " + transaction.ProcessorResponseText);
            }
            else
            {
                foreach (ValidationError error in result.Errors.DeepAll())
                {
                    Console.WriteLine("Attribute: " + error.Attribute);
                    Console.WriteLine("  Code: " + error.Code);
                    Console.WriteLine("  Message: " + error.Message);
                }
            }
        }
    }
}

You can add text-based evidence to a dispute using AddTextEvidence or AddTextEvidenceAsync. You can pass either a raw string or a TextEvidenceRequest object.

Parameters:

• disputeId: The unique identifier of the dispute.
• content: The text content of the evidence.
• TextEvidenceRequest.SequenceNumber (optional): An integer representing the sequence of the evidence.

Exceptions:

• Throws NotFoundException if the disputeId is invalid.
• Throws ArgumentException if the content is null or empty, or if the SequenceNumber is not a valid integer.

// Using raw string
Result<DisputeEvidence> result = disputeGateway.AddTextEvidence("dispute_id", "Evidence content");

// Using TextEvidenceRequest
var request = new TextEvidenceRequest {
    Content = "Evidence content",
    SequenceNumber = "1"
};
Result<DisputeEvidence> resultAsync = await disputeGateway.AddTextEvidenceAsync("dispute_id", request);

The DisputeGateway class provides methods to manage the lifecycle of disputes, including finding, accepting, finalizing, and searching for disputes. It also allows you to submit evidence (text or files) to support a dispute or remove existing evidence.

Key operations include:

• Finding: Retrieve details for a specific dispute using Find or FindAsync.
• Lifecycle: Use Accept to accept a dispute or Finalize to finalize it.
• Evidence Management: Add text-based or file-based evidence, or remove existing evidence.
• Searching: Use Search to perform advanced searches for disputes, which returns a PaginatedCollection<Dispute>.

// Example: Finding a dispute and adding text evidence
var result = disputeGateway.Find("dispute_id");
if (result.IsSuccess) {
    var dispute = result.Value;
    disputeGateway.AddTextEvidence("dispute_id", "This is my evidence content.");
}

To add file-based evidence to a dispute, use AddFileEvidence or AddFileEvidenceAsync. This requires a documentUploadId which refers to a previously uploaded document.

Methods:

• AddFileEvidence(string disputeId, string documentUploadId): A convenience method using a document ID string.
• AddFileEvidence(string disputeId, FileEvidenceRequest request): Uses a request object.

Parameters:

• disputeId: The unique identifier of the dispute.
• documentUploadId / FileEvidenceRequest.DocumentId: The ID of the uploaded document.

Exceptions:

• Throws NotFoundException if the disputeId or documentUploadId is not found.

// Using document upload ID directly
Result<DisputeEvidence> result = disputeGateway.AddFileEvidence("dispute_id", "document_upload_id");

// Using FileEvidenceRequest
var request = new FileEvidenceRequest { DocumentId = "document_upload_id" };
Result<DisputeEvidence> resultAsync = await disputeGateway.AddFileEvidenceAsync("dispute_id", request);