Introducing payment plugins

namespace PaymentMethod\Migrations;

use Plenty\Modules\Payment\Method\Contracts\PaymentMethodRepositoryContract;

/**
 * Class CreatePaymentMethod
 */
class CreatePaymentMethod
{
    /**
     * @var PaymentMethodRepositoryContract
     */
    private $paymentMethodRepositoryContract;

    /**
     * CreatePaymentMethod constructor.
     *
     * @param PaymentMethodRepositoryContract $paymentMethodRepositoryContract
     */
    public function __construct(PaymentMethodRepositoryContract $paymentMethodRepositoryContract)
    {
        $this->paymentMethodRepositoryContract = $paymentMethodRepositoryContract;
    }

    /**
     * The run method will register the payment method when the migration runs.
     */
    public function run()
    {
        $this->paymentMethodRepositoryContract->createPaymentMethod([
            'pluginKey' => 'pluginKey', // Unique key for the plugin
            'paymentKey' => 'paymentKey', // Unique key for the payment method
            'name' => 'Payment Name' // Default name for the payment method
        ]);
    }
}

namespace PaymentMethod\Methods;

use Plenty\Plugin\ConfigRepository;
use Plenty\Modules\Payment\Method\Services\PaymentMethodBaseService;
use Plenty\Modules\Basket\Contracts\BasketRepositoryContract;
use Plenty\Modules\Basket\Models\Basket;

/**
 * Class PaymentMethod
 * @package PaymentMethod\Methods
 */
class PaymentMethod extends PaymentMethodBaseService
{
    /** @var BasketRepositoryContract */
    private $basketRepo;

    /** @var  SettingsService */
    private $settings;

    /** @var  Checkout */
    private $checkout;

    /**
     * PaymentMethod constructor.
     * @param BasketRepositoryContract $basketRepo
     * @param SettingsService $settingsService
     * @param Checkout $checkout
     */
    public function __construct(
        BasketRepositoryContract $basketRepo,
        SettingsService $settingsService,
        Checkout $checkout
    ) {
        $this->basketRepo = $basketRepo;
        $this->settings = $settingsService;
        $this->checkout = $checkout;
    }

    /**
     * Check if the payment method is active.
     * Return true if the payment method is active, if not return false.
     *
     * @return bool
     */
    public function isActive(): bool
    {
        /**
         * In our assistant, we let the user decide in which shipping countries the payment method
         * is allowed, therefore we have to check it here.
         */
        if (!in_array($this->checkout->getShippingCountryId(), $this->settings->getShippingCountries())) {
            return false;
        }

        return true;
    }

    /**
     * Get the name of the payment method.
     *
     * @param string $lang
     * @return string
     */
    public function getName(string $lang = 'de'): string
    {
        /** @var Translator $translator */
        $translator = pluginApp(Translator::class);
        /**
         * Here, we use the translator class to allow multilingualism. Every variable
         * of the translator can be found and configured in the CMS » Multilingualism menu.
         */
        return $translator->trans('PaymentMethod::PaymentMethod.paymentMethodName', [], $lang);
    }

    /**
     * Return an additional payment fee for the payment method.
     *
     * @return float
     */
    public function getFee(): float
    {
        return 0.00;
    }

    /**
     * Get the path of the icon.
     *
     * @return string
     */
    public function getIcon(string $lang): string
    {
        /**
         * Here, we want to get the logo, but we let our user decide in the assistant if
         * he wants a custom logo or the basic logo. Therefore, we have to get our logo settings
         * and either return the uploaded image url or the default image.
         */
        if ($this->settings->getSetting('logo') == 1) {
            return $this->settings->getSetting('logoUrl');
        } elseif ($this->settings->getSetting('logo') == 2) {
            $app = pluginApp(Application::class);
            $icon = $app->getUrlPath('paymentmethod').'/images/icon.png';
            return $icon;
        }
        return '';
    }

    /**
     * Get the description of the payment method.
     *
     * @return string
     */
    public function getDescription(string $lang): string
    {
        /**
         * Here, we want to use the frontend session to detect the language and
         * return the description of a payment method.
         */
         /** @var FrontendSessionStorageFactoryContract $session */
        $session = pluginApp(FrontendSessionStorageFactoryContract::class);
        $lang = $session->getLocaleSettings()->language;

        /**
         * Here, we use the translator class to allow multilingualism. Every variable of
         * the translator can be found and configured in the CMS » Multilingualism menu.
         */
         /** @var Translator $translator */
        $translator = pluginApp(Translator::class);
        return $translator->trans('PaymentMethod::PaymentMethod.paymentMethodDescription', [], $lang);
    }

    /**
     * Return an URL with additional information about the payment method shown in the frontend
     * in the corresponding language.
     *
     * @param string $lang
     * @return string
     */
    public function getSourceUrl(string $lang): string
    {
        return '';
    }

    /**
     * Check if it is allowed to switch to this payment method after the order has been placed.
     *
     * @return bool
     */
    public function isSwitchableTo(): bool
    {
        return false;
    }

    /**
     * Check if it is allowed to switch from this payment method to another after the order has been placed.
     *
     * @return bool
     */
    public function isSwitchableFrom(): bool
    {
        return false;
    }

    /**
     * Check if this payment method should be searchable in the back end.
     *
     * @return bool
     */
    public function isBackendSearchable(): bool
    {
        return true;
    }

    /**
     * Check if this payment method should be active in the back end.
     *
     * @return bool
     */
    public function isBackendActive(): bool
    {
        return true;
    }

    /**
     * Get the name for the back end.
     *
     * @param string $lang
     * @return string
     */
    public function getBackendName(string $lang): string
    {
        return $this->getName($lang);
    }

    /**
     * Check if this payment method can handle subscriptions.
     *
     * @return bool
     */
    public function canHandleSubscriptions(): bool
    {
        return true;
    }

    /**
     * Return the icon for the back end, shown in the payments UI.
     *
     * @return string
     */
    public function getBackendIcon(): string
    {
        $app = pluginApp(Application::class);
        $icon = $app->getUrlPath('paymentmethod').'/images/backend_icon.svg';
        return $icon;
    }
}

namespace PaymentMethod\Providers;

use Plenty\Plugin\ServiceProvider;
use Plenty\Modules\Basket\Events\Basket\AfterBasketCreate;
use Plenty\Modules\Basket\Events\Basket\AfterBasketChanged;
use Plenty\Modules\Basket\Events\BasketItem\AfterBasketItemAdd;

/**
 * Class PaymentMethodServiceProvider
 * @package PaymentMethod\Providers
 */
class PaymentMethodServiceProvider extends ServiceProvider
{
    public function register()
    {
    }

    /**
     * Register the payment methods within the boot process of the plugin.
     *
     * @param PaymentMethodContainer $payContainer
     */
    public function boot(PaymentMethodContainer $payContainer)
    {
        // Register the payment method in the payment method container.
        $payContainer->register('pluginKey::paymentKey', PaymentMethod::class,
            [
                AfterBasketChanged::class,
              AfterBasketItemAdd::class,
                AfterBasketCreate::class,
                            AfterBasketItemUpdate::class,
                AfterBasketItemRemove::class,
                FrontendLanguageChanged::class,
                FrontendShippingCountryChanged::class,
                FrontendCustomerAddressChanged::class
            ]
        );

        ...
    }
}

...

// Listen for the event that gets the payment method content.
$eventDispatcher->listen(GetPaymentMethodContent::class,
   function(GetPaymentMethodContent $event) use( $paymentHelper, $basket, $paymentService)
   {
       // Check if the given method of payment is one of the plugin.
        if($event->getMop() == $paymentHelper->getPayPalMopId())
        {
              // Collect necessary informations
              $basket = $basket->load();

              ...

              // Set the content and return type for the event.
              $event->setValue($content);
              $event->setType($returnType);
        }
   });

// Listen for the event that executes the payment.
$eventDispatcher->listen(ExecutePayment::class,
  function(ExecutePayment $event) use ( $paymentHelper, $paymentService)
  {
        // Check if the given method of payment is one of the plugin.
        if($event->getMop() == $paymentHelper->getPayPalMopId())
        {
              // Execute the payment
              ....

              // Check whether the payment has been executed successfully.
              if($paymentService->getReturnType() != 'errorCode')
              {
                    // Create a payment in plentymarkets with the data from the payment provider.
                    $plentyPayment = $paymentHelper->createPlentyPaymentFromJson($payPalPayment);
                    if($plentyPayment instanceof Payment)
                    {
                          // Assign the payment to an order in plentymarkets.
                          $paymentHelper->assignPlentyPaymentToPlentyOrder($plentyPayment, $event->getOrderId());

                          // Set the return type and value for the event.
                          $event->setType('success');
                          $event->setValue('The payment has been executed successfully!');
                    }
              }
              else
              {
                  // Handle an error case and set the return type and value for the event.
                  $event->setType('error');
                  $event->setValue('The payment could not be executed!');
              }
        }
  });

...

      ...

      /**
      * Create a payment in plentymarkets from an array.
      *
      * @param array $data
      * @return Payment
      */
      public function createPlentyPaymentFromArray(array $data)
      {
        $paymentData = [];

        // Set the payment data
        $paymentData['mopId']           = (int)$this->getlMopId(); // Load the unique payment method ID from the plugin.
        $paymentData['transactionType'] = 2;
        $paymentData['status']          = $this->mapStatus($data['status']); // Map the status from the payment provider to the payment status.
        $paymentData['currency']        = $data['currency'];
        $paymentData['amount']          = $data['amount'];
        $paymentData['receivedAt']       = $data['entryDate'];

        $paymentData['properties'] = [
          [
            'typeId'  => 1 // Transaction Id
            'value'   => $data['transactionId']
          ], [
            'typeId'  => 3 // Booking text
            'value'   => $data['bookingText']
          ], [
            'typeId'  => 23 // Payment origin
            'value'   => 6 // Plugin origin
          ]
        ]

        $payment = $this->paymentRepository->createPayment($paymentData);
        return $payment;
      }

      ...

      ...

      /**
      * Assign the payment to an order in plentymarkets.
      *
      * @param Payment $payment
      * @param int $orderId
      */
      public function assignPlentyPaymentToPlentyOrder(Payment $payment, int $orderId)
      {
        // Load the order by the given order ID.
        /** @var OrderRepositoryContract $orderRepositoryContract */
        $orderRepositoryContract = pluginApp(OrderRepositoryContract::class);
        $order = $orderRepositoryContract->findOrderById($orderId);

        // Check whether the order truly exists in plentymarkets.
        if(!is_null($order) && $order instanceof Order)
        {
          // Assign the given payment to the given order
          /** @var PaymentOrderRelationRepositoryContract $paymentOrderRelationRepositoryContract */
          $paymentOrderRelationRepositoryContract = pluginApp(PaymentOrderRelationRepositoryContract::class);
          $paymentOrderRelationRepositoryContract->createOrderRelation($payment, $order);
        }
      }

      ...

<?php

namespace PaymentMethod\Methods;

class PaymentMethod extends PaymentMethodBaseService
{
  ...

  /**
    * Check if it is allowed to switch to this payment method.
    *
    * @param int $orderId
    * @return bool
    */
    public function isSwitchableTo($orderId)
    {
      return true;
    }

    /**
    * Check if it is allowed to switch from this payment method to another.
    *
    * @param int $orderId
    * @return bool
    */
    public function isSwitchableFrom($orderId)
    {
      // Check the current status of the payment, check if the order is already prepared or something similar.
      // Return true if it is allowed to change from this payment method to another.
      return true;
    }
}

...

{
  "key":"PaymentMethod\\Providers\\DataProvider\\ReinitializePayment",
  "name":"Payment Method Reinitialize Payment",
  "description":"Display the Payment Button after the Payment changed to the PaymentMethod"
},
{
  "key":"PaymentMethod\\Providers\\DataProvider\\PaymentMethodReinitializePaymentScript",
  "name":"PaymentMethod Reinitialize Payment Script",
  "description":"A Script for displaying the Payment Button after the Payment changed to the PaymentMethod"
}

...

<?php

namespace PaymentMethod\Providers\DataProvider;

use Plenty\Plugin\Templates\Twig;
use PaymentMethod\Helpers\PaymentHelper;

class PaymentMethodReinitializePayment
{
  public function call(Twig $twig, $arg):string
  {
    /** @var PaymentHelper $paymentHelper */
    $paymentHelper = pluginApp(PaymntHelper::class);
    $paymentMethodId = $paymentHelper->getPaymentMethodId();
    return $twig->render('PaymentMethod::PaymentMethodReinitializePayment', ["order" => $arg[0], "paymentMethodId" => $paymentMethodId]);
  }
}

<?php

namespace PaymentMethod\Providers\DataProvider;

use Plenty\Plugin\Templates\Twig;
use PaymentMethod\Helper\PaymentHelper;

class PaymentMethodReinitializePaymentScript
{
  public function call(Twig $twig):string
  {
    $paymentHelper = pluginApp(PaymentHelper::class);
    $paymentMethodId = $paymentHelper->getPaymentMethodId();
    return $twig->render('PaymentMethod::PaymentMethodReinitializePaymentScript', ['mopIds' => ['paymentMethodId' => $paymentMethodId]]);
  }
}

{% set paymentId = 0 %}
{% set paidStatus = '' %}

{% set properties = order.properties %}

{% for property in properties %}
  {% if property.typeId == 3 %}
    {% set paymentId = property.value %}
  {% endif %}
  {% if property.typeId == 4 %}
    {% set paidStatus = property.value %}
  {% endif %}
{% endfor %}
{% if (paymentId == paymentMethodId) and (paidStatus != 'fullyPaid') %}
  {% set display = "block" %}
{% else %}
  {% set display = "none" %}
{% endif %}

{% if services.template.isCurrentTemplate('tpl.my-account') %}
  <button id="reinitPaymentMethod-{{order.id}}" class="btn btn-primary btn-block" @click="" data-toggle="modal" data-target="#paymentMethod" :disabled="" style="display: {{ display }}; margin-top: 0.5rem">
    {{ trans("PaymentMethod::PaymentMethod.myAccountReinitPayment") }}
  </button>
{% elseif services.template.isCurrentTemplate('tpl.confirmation') %}
  <div id="reinitPaymentMethod-{{order.id}}" class="row con-reinit" style="display: {{ display }};">
    <strong class="col-xs-6 col-sm-5"></strong>
    <span class="col-xs-6 col-sm-7">
      <a class="payment-confirmation-btn" @click="" data-toggle="modal" data-target="#payPalPlusWall" :disabled="">
        <span>{{ trans("PayPal::PayPal.myAccountReinitPayment") }}</span>
      </a>
    </span>
  </div>
{% endif %}

<script type="text/javascript">
  $(function () {
    $("[id^='reinitPaymentMethod-']").click(function () {
      var orderId = $(this).attr('id').split('-')[1];
      $.get("/payment/paymentMethod/payOrderNow/"+orderId, function(data)
      {
        window.location = data;
      });
    });
  });

  document.addEventListener('historyPaymentMethodChanged', e => {
    for(let property in e.detail.newOrder.order.properties){
      if(e.detail.newOrder.order.properties[property].typeId === 3){
        if (e.detail.newOrder.order.properties[property].value == {{ mopIds.pp }}) {
          document.getElementById("reinitPaymentMethod-" + e.detail.oldOrder.order.id).style.display = "block";
        } else {
          document.getElementById("reinitPaymentMethod-" + e.detail.oldOrder.order.id).style.display = "none";
        }
      }
    }
  });
</script>

<?php

namespace PaymentMethod\Procedures;

...

/**
 * Class RefundEventProcedure
 * @package PaymentMethod\Procedures
 */
class RefundEventProcedure
{
    /**
     * @param EventProceduresTriggered $eventProceduresTriggered
     * @param PaymentService $paymentService
     * @param PaymentRepositoryContract $paymentContract
     */
    public function run(
        EventProceduresTriggered $eventProceduresTriggered,
        PaymentService $paymentService,
        PaymentRepositoryContract $paymentContract
    )
    {
        /**
         * Get current order the event is triggered from.
         *
         * @var Order $order
         */
        $order = $eventProceduresTriggered->getOrder();

        /**
         * Load the payment from the current order to get the amount and the currency.
         *
         * @var Payment $payment
         */
        $payment = $paymentContract->getPaymentsByOrderId($order->id);
        $paymentData = [
          'currency' => $payment->currency,
          'total'    => $payment->amount
        ];

        // Refund the given payment.
        $paymentService->refundPayment($paymentData);
    }
}

<?php

namespace PaymentMethod\Providers;

use Plenty\Modules\EventProcedures\Services\Entries\ProcedureEntry;
use Plenty\Modules\EventProcedures\Services\EventProceduresService;

...

use PayPal\Procedures\RefundEventProcedure;

...

/**
 * Class PayPalServiceProvider
 * @package PaymentMethod\Providers
 */
class PaymentMethodServiceProvider extends ServiceProvider
{
  /**
   * Register the route service provider and bind event procedures.
   */
  public function register()
  {
      ...
      $this->getApplication()->bind(RefundEventProcedure::class);
  }

  public function boot(EventProceduresService $eventProceduresService)
  {
    // Register PaymentMethod Refund Event Procedure
    $eventProceduresService->registerProcedure(
      'plentyPaymentMethod',
      ProcedureEntry::PROCEDURE_GROUP_ORDER,
      [
        'de' => 'Rückzahlung der Zahlung',
        'en' => 'Refund of the payment'
      ],
      '\PaymentMethod\Procedures\RefundEventProcedure@run');
  }

  ...
}

<?php

namespace PaymentMethod\Providers;

use Plenty\Plugin\RouteServiceProvider;
use Plenty\Plugin\Routing\Router;

/**
* Class PaymentMethodRouteServiceProvider
* @package PaymentMethod\Providers
*/
class PaymentMethodRouteServiceProvider extends RouteServiceProvider
{
  /**
  * @param Router $router
  */
  public function map(Router $router)
  {
    // Get the PayPal success and cancellation URLs
    $router->get('payment/paymentMethod/checkoutSuccess', 'PaymentMethod\Controllers\PaymentController@checkoutSuccess');
    $router->get('payment/paymentMethod/checkoutCancel' , 'PaymentMethod\Controllers\PaymentController@checkoutCancel' );
    $router->get('payment/paymentMethod/expressCheckout', 'PaymentMethod\Controllers\PaymentController@expressCheckout');
    $router->post('payment/paymentMethod/notification'  , 'PaymentMethod\Controllers\PaymentNotificationController@handleNotification');
  }
}

<?php

namespace PaymentMethod\Controllers;


use Plenty\Plugin\Http\Response;

/**
 * Class PaymentController
 * @package PaymentMethod\Controllers
 */
class PaymentController
{
  /**
   * @param Router $router
   */
  public function checkoutSuccess(Response $response)
  {
    /**
     * Do some stuff
     */
     return $response->redirectTo('/checkout?readonlyCheckout=1');
  }
}

$eventDispatcher->listen(
  CheckoutReadonlyChanged::class,
  function (CheckoutReadonlyChanged $event) use ($sessionStorageService) {
    if($event->isReadOnlyCheckout() === false) {
      // For example: Delete all session data
    }
});

<?php

namespace PaymentMethod\Services;

use Plenty\Modules\Account\Contact\Contracts\ContactAddressRepositoryContract;
use Plenty\Modules\Frontend\Services\AccountService;

use Plenty\Modules\Account\Address\Contracts\AddressRepositoryContract;
use Plenty\Modules\Account\Address\Models\Address;

/**
* Class ContactService
* @package PaymentMethod\Services
*/
class ContactService
{
  /**
  * @var AddressRepositoryContract
  */
  private $addressRepository;

  /**
  * ContactService constructor.
  * @param AddressRepositoryContract $addressRepository
  */
  public function __construct(AddressRepositoryContract $addressRepository)
  {
    $this->addressRepository = $addressRepository;
  }

  /**
  * Create an address
  *
  * @param array $params
  * @return Address
  */
  public function createAddress(array $params):Address
  {
    if (isset($params['shipping_address']) && !empty($params['shipping_address'])) {
        /**
         * Map the address to a plenty address
         * @var Address $address
         */
        $address = $this->mapAddressToAddress($params'shipping_address']);

        /** @var AccountService $accountService */
        $accountService = pluginApp(AccountService::class);

        $contactId = $accountService->getAccountContactId();

        // if there is a logged in user, update the contact delivery address
        if (!empty($contactId) && $contactId > 0) {
            /** @var ContactAddressRepositoryContract $contactAddress */
            $contactAddress = pluginApp(ContactAddressRepositoryContract::class);

            $createdAddress = $contactAddress->createAddress($address->toArray(), $contactId, AddressRelationType::DELIVERY_ADDRESS);
        } else {
            // if the user is a guest, create a address and set the invoice address ID if necessary
            $createdAddress = $this->addressRepository->createAddress($address->toArray());

            //Set the guest email address in the session to prevent a second login
            $this->sessionStorageService->setSessionValue(SessionStorageKeys::GUEST_EMAIL, $email);

            if (empty($this->checkout->getCustomerInvoiceAddressId())) {
                // set the customer invoice address ID
                $this->checkout->setCustomerInvoiceAddressId($createdAddress->id);
            }
        }

        // update/set the customer shipping address ID
        $this->checkout->setCustomerShippingAddressId($createdAddress->id);

        return $createdAddress;
      }
   }
}

use Plenty\Modules\Item\Variation\Contracts\VariationRepositoryContract;

...

$variationId = 1000; // Variation ID is given in the basket items.
$surcharge = 0;

// Load the item with the variation ID.
$variationRepository = pluginApp(VariationRepositoryContract::class);
$variation = $variationRepository->findById($variationId);
$item = $variation->item;

// Load each property and check if it has a surcharge.
foreach ($item->itemProperties as $itemProperty) {
    $property = $itemProperty->property;
    if (!$property->isOderProperty && $property->isShownAsAdditionalCosts) {
        // The surcharge is given in the system currency.
        $surcharge += $property->surcharge;
    }
}

use Plenty\Modules\Order\Models\OrderItemType;

...

$surcharge = 0;

foreach ($order->orderItems as $orderItem) {
    if ($orderItem->typeId == OrderItemType::TYPE_DEPOSIT) {
        // Get the amount in order currency (see the section Currencies).
        $orderItemAmount = $orderItem->amount;
        $surcharge += $orderItemAmount->priceGross;
    }
}

use Plenty\Modules\Basket\Contracts\BasketRepositoryContract;
use Plenty\Modules\Order\Coupon\Campaign\Contracts\CouponCampaignRepositoryContract;
use Plenty\Modules\Order\Coupon\Campaign\Models\CouponCampaign;

...

$basketRepository = pluginApp(BasketRepositoryContract::class);
$basket = $basketRepository->load();

// In the basket, the amount of promotional coupons and of gift cards are
// saved in the same variable.
$couponAmount = $basket->couponDiscount; // Given as negative amount, e.g. -10.

$isPromotionalCoupon = false;
$isGiftCard = false;

if ($couponAmount != 0 && strlen($basket->couponCode)) {
    $couponCampaignRepository = pluginApp(CouponCampaignRepositoryContract::class);
    $couponCampaign = $couponCampaignRepository->findByCouponCode($basket->couponCode);

    $isPromotionalCoupon = ($couponCampaign->campaignType == CouponCampaign::CAMPAIGN_TYPE_COUPON && $couponCampaign->couponType == CouponCampaign::COUPON_TYPE_PROMOTION);
    $isGiftCard = ($couponCampaign->campaignType == CouponCampaign::CAMPAIGN_TYPE_COUPON && $couponCampaign->couponType == CouponCampaign::COUPON_TYPE_SALES);
}

use Plenty\Modules\Order\Models\OrderItemType;

...

$couponAmountPromotionalCoupon = 0;
$couponAmountGiftCard = 0;

foreach ($order->orderItems as $orderItem) {
    if ($orderItem->typeId == OrderItemType::TYPE_PROMOTIONAL_COUPON) {
        // Given as negative amount, e.g. -10.
        $couponAmountPromotionalCoupon += $orderItem->amount->priceGross;
    }
    if ($orderItem->typeId == OrderItemType::TYPE_GIFT_CARD) {
        // Given as negative amount, e.g. -10.
        $couponAmountGiftCard += $orderItem->amount->priceGross;
    }
}

use Plenty\Modules\Basket\Contracts\BasketRepositoryContract;
use Plenty\Modules\Frontend\Contracts\CurrencyExchangeRepositoryContract;

...
$basketRepository = pluginApp(BasketRepositoryContract::class);

// Get the shopping cart from the current customer session.
$basket = $basketRepository->load();

// Get the currency of the shopping cart.
$basketCurrency = $basket->currency;

try {
   $currencyService = pluginApp(CurrencyExchangeRepositoryContract::class);

   // Get the default system currency.
   $defaultCurrency = $currencyService->getDefaultCurrency();

   // If the basket currency and the default currency are different, the basket is in the foreign currency.
   if ($basketCurrency != $defaultCurrency) {
      // Get exchange ratio for basket currency to default system currency.
      $exchangeRatio = $currencyService->getExchangeRatioByCurrency($basketCurrency);

      // Convert basket foreign amount to default system currency amount.
      $amountInSystemCurrency = $currencyService->convertToDefaultCurrency($basketCurrency, $basket->amount, $exchangeRatio);
   }
} catch (\Exception $currencyServiceException) {
   // Define what to do if an exception is thrown by the currency service.
}
...

...
// If there is already an existing order, the information can be found in the order amounts.

// Get the amount of an order in foreign currency if it exists otherwise in system currency.
$orderAmount = $order->amount;

// Get the currency of the order amount.
$orderAmountCurrency = $orderAmount->currency;

// Flag that states whether the current currency is the same as system currency or not.
$orderAmountIsSystemCurrency = $orderAmount->isSystemCurrency;

// Get the exchange rate for converting the current currency into the system currency.
// The exchange rate is 1 if the currency of the amount is the same as system currency.
$orderAmountExchangeRateToSystemCurrency = $orderAmount->exchangeRate;
...

use Plenty\Modules\Accounting\Contracts\AccountingLocationRepositoryContract;
use Plenty\Modules\System\Contracts\WebstoreConfigurationRepositoryContract;
use Plenty\Plugin\Application;

...

// Get the plenty ID.
$application = pluginApp(Application::class);
$plentyId = $application->getPlentyId();

// Load the default accounting location ID from the webstore configuration.
$webstoreConfigurationRepository = pluginApp(WebstoreConfigurationRepositoryContract::class);
$webstoreConfiguration = $webstoreConfigurationRepository->findByPlentyId(plentyId);
$accountingLocationId = $webstoreConfiguration->defaultAccountingLocation;

// Load the accounting location settings.
$accountingLocationRepository = pluginApp(AccountingLocationRepositoryContract::class);
$accountingLocationSettings = $accountingLocationRepository->getSettings(accountingLocationId);

// Can be 2 or 4.
$numberOfDecimalPlaces = $accountingLocationSettings->numberOfDecimalPlaces;
// Decide whether to round intermedial values or totals.
$roundTotalsOnly = $accountingLocationSettings->roundTotalsOnly;

$numberOfDecimalPlaces = $order->numberOfDecimals;
$roundTotalsOnly = $order->roundTotalsOnly;

use Plenty\Modules\Basket\Contracts\BasketRepositoryContract;

...
$basketRepository = pluginApp(BasketRepositoryContract::class);

// Get the basket of the current customer session.
$basket = $basketRepository->load();

// VAT total amount can be loaded from the basket.
$basketVatTotalAmount = $basket->basketAmount - $basket->basketAmountNet;

// The individual VAT amounts of basket items can be calculated.
$shippingCostVatRate = 0.00;
foreach ($basket->basketItems as $basketItem) {
   if ($basketItem instanceof BasketItem) {

      // VAT rate of a basket item.
      $basketItemVatRate = $basketItem->vat;

      // The rebate inpercentage for the basket.
      // This discount can either be set as:
      // A discount scale for items, a customer class discount or a discount based on the payment method.
      $discount = 0.00;
      if ($basket->basketRebate > 0.00) {
         // Discount of a basket item.
         $discount = $basketItem->price * ($basket->basketRebate / 100);
      }

      // The VAT amount of a basket item.
      $basketItemVatAmount = (($basketItem->price - $discount) * ($basketItem->vat / (100.0 + $basketItem->vat))) * $basketItem->quantity;

      // VAT rate of the shipping cost item is the maximum VAT rate of all basket items.
      $shippingCostVatRate = max($basketItemVatRate, $shippingCostVatRate);
   }
}

// Shipping cost item
$shippingCosts = $basket->shippingAmount;
$ShippingCostItemVatAmount = $shippingCosts * ($shippingCostVatRate / (100.0 + $shippingCostVatRate));
$vatTotalAmount += $ShippingCostItemVatAmount;
...

...
// If there is already an existing order, the information can be loaded from order or order items.

// VAT total amount can be loaded from the order.
$basketVatTotalAmount = $order->amount->vatTotal;

// The individual VAT amounts of order items can be calculated.
foreach ($order->orderItems as $orderItem) {
   // VAT rate of an order item.
   $orderItemVatRate = $orderItem->vatRate;

   // Get the amount of an order in foreign currency if it exists otherwise in system currency.
   $orderItemAmount = $orderItem->amount;

   // The VAT amount of an order item.
   $orderItemVatAmount =  $orderItemAmount->priceGross - $orderItemAmount->priceNet;
}
...

<?php

namespace PaymentMethod\Methods;

/**
 * Class PaymentMethod
 * @package PaymentMethod\Methods
 */
class PaymentMethod extends PaymentMethodBaseService
{

  ...

  /**
  * Return Payment Method Fee
  *
  * @return float
  */
  public function getFee()
  {
      return 0.00;
  }
}