Confirm the Order

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            // Request body for this sample:
            // {
            //   "payment_source": {
            //     "paypal": {
            //       "name": {
            //         "given_name": "John",
            //         "surname": "Doe"
            //       },
            //       "email_address": "customer@example.com",
            //       "experience_context": {
            //         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
            //         "brand_name": "EXAMPLE INC",
            //         "locale": "en-US",
            //         "landing_page": "LOGIN",
            //         "shipping_preference": "SET_PROVIDED_ADDRESS",
            //         "user_action": "PAY_NOW",
            //         "return_url": "https://example.com/returnUrl",
            //         "cancel_url": "https://example.com/cancelUrl"
            //       }
            //     }
            //   }
            // }

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        // Request body for this sample:
        // {
        //   "payment_source": {
        //     "paypal": {
        //       "name": {
        //         "given_name": "John",
        //         "surname": "Doe"
        //       },
        //       "email_address": "customer@example.com",
        //       "experience_context": {
        //         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
        //         "brand_name": "EXAMPLE INC",
        //         "locale": "en-US",
        //         "landing_page": "LOGIN",
        //         "shipping_preference": "SET_PROVIDED_ADDRESS",
        //         "user_action": "PAY_NOW",
        //         "return_url": "https://example.com/returnUrl",
        //         "cancel_url": "https://example.com/cancelUrl"
        //       }
        //     }
        //   }
        // }

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

// Request body for this sample:
// {
//   "payment_source": {
//     "paypal": {
//       "name": {
//         "given_name": "John",
//         "surname": "Doe"
//       },
//       "email_address": "customer@example.com",
//       "experience_context": {
//         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
//         "brand_name": "EXAMPLE INC",
//         "locale": "en-US",
//         "landing_page": "LOGIN",
//         "shipping_preference": "SET_PROVIDED_ADDRESS",
//         "user_action": "PAY_NOW",
//         "return_url": "https://example.com/returnUrl",
//         "cancel_url": "https://example.com/cancelUrl"
//       }
//     }
//   }
// }

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Request body for this sample:
# {
#   "payment_source": {
#     "paypal": {
#       "name": {
#         "given_name": "John",
#         "surname": "Doe"
#       },
#       "email_address": "customer@example.com",
#       "experience_context": {
#         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
#         "brand_name": "EXAMPLE INC",
#         "locale": "en-US",
#         "landing_page": "LOGIN",
#         "shipping_preference": "SET_PROVIDED_ADDRESS",
#         "user_action": "PAY_NOW",
#         "return_url": "https://example.com/returnUrl",
#         "cancel_url": "https://example.com/cancelUrl"
#       }
#     }
#   }
# }

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Request body for this sample:
// {
//   "payment_source": {
//     "paypal": {
//       "name": {
//         "given_name": "John",
//         "surname": "Doe"
//       },
//       "email_address": "customer@example.com",
//       "experience_context": {
//         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
//         "brand_name": "EXAMPLE INC",
//         "locale": "en-US",
//         "landing_page": "LOGIN",
//         "shipping_preference": "SET_PROVIDED_ADDRESS",
//         "user_action": "PAY_NOW",
//         "return_url": "https://example.com/returnUrl",
//         "cancel_url": "https://example.com/cancelUrl"
//       }
//     }
//   }
// }

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Request body for this sample:
# {
#   "payment_source": {
#     "paypal": {
#       "name": {
#         "given_name": "John",
#         "surname": "Doe"
#       },
#       "email_address": "customer@example.com",
#       "experience_context": {
#         "payment_method_preference": "IMMEDIATE_PAYMENT_REQUIRED",
#         "brand_name": "EXAMPLE INC",
#         "locale": "en-US",
#         "landing_page": "LOGIN",
#         "shipping_preference": "SET_PROVIDED_ADDRESS",
#         "user_action": "PAY_NOW",
#         "return_url": "https://example.com/returnUrl",
#         "cancel_url": "https://example.com/cancelUrl"
#       }
#     }
#   }
# }

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Scenario: 400 - Confirm Order - 400 Bad Request Error - Missing Required Parameter - Payment Source

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Scenario: 403 - Confirm Order - 403 Forbidden Error -  Invalid PayPal Wallet Vault ID

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            // Request body for this sample:
            // {
            //   "payment_source": {
            //     "paypal": {
            //       "vault_id": "8kk845"
            //     }
            //   }
            // }

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        // Request body for this sample:
        // {
        //   "payment_source": {
        //     "paypal": {
        //       "vault_id": "8kk845"
        //     }
        //   }
        // }

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

// Request body for this sample:
// {
//   "payment_source": {
//     "paypal": {
//       "vault_id": "8kk845"
//     }
//   }
// }

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Request body for this sample:
# {
#   "payment_source": {
#     "paypal": {
#       "vault_id": "8kk845"
#     }
#   }
# }

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Request body for this sample:
// {
//   "payment_source": {
//     "paypal": {
//       "vault_id": "8kk845"
//     }
//   }
// }

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Request body for this sample:
# {
#   "payment_source": {
#     "paypal": {
#       "vault_id": "8kk845"
#     }
#   }
# }

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Scenario: 500 - Confirm Order - 500 Internal Server Error - A system error has occurred

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 404 - Resource Not Found

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            OrdersController ordersController = client.OrdersController;

            ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput
            {
                Id = "5O190127TN364715T",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<Order> result = await ordersController.ConfirmOrderAsync(confirmOrderInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.OrdersController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 404 - Resource Not Found

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        OrdersController ordersController = client.getOrdersController();

        ConfirmOrderInput confirmOrderInput = new ConfirmOrderInput.Builder(
            "5O190127TN364715T",
            null
        )
        .prefer("return=minimal")
        .build();

        ordersController.confirmOrderAsync(confirmOrderInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 404 - Resource Not Found

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const ordersController = client.ordersController;

const collect = {
  id: '5O190127TN364715T',
  prefer: 'return=minimal'
}

try {
  const response = await ordersController.confirmOrder(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

orders_controller = client.orders_controller

# Scenario: 404 - Resource Not Found

collect = {
    'id': '5O190127TN364715T',
    'prefer': 'return=minimal'
}
result = orders_controller.confirm_order(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$OrdersController = $client->getOrdersController();

// Scenario: 404 - Resource Not Found

$collect = [
    'id' => '5O190127TN364715T',
    'prefer' => 'return=minimal'
];

$apiResponse = $ordersController->confirmOrder($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

orders_controller = client.orders_controller

# Scenario: 404 - Resource Not Found

collect = {
  'id' => '5O190127TN364715T',
  'prefer' => 'return=minimal'
}

result = orders_controller.confirm_order(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end