Get a list of available banks

@param int|null $paymentMethodId If empty, the paymentMethodId for iDEAL will be used
@return array
357285
public static function getBanks($paymentMethodId = 10)
    {
        $paymentMethods = self::getList();
        if (isset($paymentMethods[$paymentMethodId])) {
            return $paymentMethods[$paymentMethodId]['banks'];
        }
        return array();
    }
682414
public function getPartialPayments()
    {
        if (!$this->isInDB()) {
            return null;
        }

        return Payment::get()
            ->filter('InitialPaymentID', $this->ID)
            ->sort(array('Created' => 'DESC', 'ID' => 'DESC'));
    }
1330869
protected function getAvailablePaymentListAsString()
    {
        static $sPaymentMethods = null;

        if (null === $sPaymentMethods) {
            $sPaymentMethods = '';
            $oPaymentList = $this->getAvailablePaymentList();
            if (null !== $oPaymentList) {
                if ($oPaymentList->Length() > 0) {
                    while ($oPaymentMethod = $oPaymentList->Next()) {
                        if ('' != $sPaymentMethods) {
                            $sPaymentMethods .= ', ';
                        }
                        $sPaymentMethods .= $oPaymentMethod->GetName();
                    }
                }
            }
        }

        if (!is_string($sPaymentMethods)) {
            $sPaymentMethods = '';
        }

        return $sPaymentMethods;
    }
115021
public function toOptionArray()
    {
        $return = [];

        $paymentMethodCodes = $this->_installmentsHelper->getAllInstallmentPaymentMethodCodes();
        foreach ($paymentMethodCodes as $paymentMethodCode) {
            $return[] = [
                'value' => $paymentMethodCode,
                'label' => ucfirst(str_replace('_', ' ', $paymentMethodCode))
            ];
        }
        return $return;
    }
1193380
public function getPaymentMethods()
    {
        $paymentMethods = array();

        foreach ($this->data['data'] as $method) {
            $paymentMethods[] = new PaymentMethod(
                $method['id'],
                $method['description']
            );
        }

        return $paymentMethods;
    }
495439
public function filterPaymentMethods(PaymentMethodsTransfer $paymentMethodsTransfer, QuoteTransfer $quoteTransfer): PaymentMethodsTransfer
    {
        $availableMethods = $this->getAvailablePaymentMethods($quoteTransfer);

        $result = new ArrayObject();

        foreach ($paymentMethodsTransfer->getMethods() as $paymentMethod) {
            if ($this->isPaymentMethodPayone($paymentMethod) && !$this->isAvailable($paymentMethod, $availableMethods)) {
                continue;
            }
            $result->append($paymentMethod);
        }
        $paymentMethodsTransfer->setMethods($result);

        return $paymentMethodsTransfer;
    }
722235
public function getNotMappedToRDFaPayments()
    {
        $oPayments = oxNew(\OxidEsales\Eshop\Application\Model\PaymentList::class);
        $oPayments->loadNonRDFaPaymentList();

        return $oPayments;
    }
336208
private static function filterCountry($paymentMethods, $country)
    {
        $output = array();
        foreach ($paymentMethods as $paymentMethod) {
            if (in_array($country, $paymentMethod['countries'], true)
              || in_array('ALL', $paymentMethod['countries'], true)
            ) {
                $output[] = $paymentMethod;
            }
        }
        return $output;
    }
333228
public function getList(array $options = array())
    {
        $methods = &gplcart_static(gplcart_array_hash(array('payment.methods' => $options)));

        if (isset($methods)) {
            return $methods;
        }

        $methods = $this->getDefaultList();
        $this->hook->attach('payment.methods', $methods, $this);

        $weights = array();
        foreach ($methods as $id => &$method) {

            $method['id'] = $id;

            if (!isset($method['weight'])) {
                $method['weight'] = 0;
            }

            if (!empty($options['status']) && empty($method['status'])) {
                unset($methods[$id]);
                continue;
            }

            if (!empty($options['module'])
                && (empty($method['module']) || !in_array($method['module'], (array) $options['module']))) {
                unset($methods[$id]);
                continue;
            }

            $weights[] = $method['weight'];
        }

        if (empty($methods)) {
            return array();
        }

        // Sort by weight then by key
        array_multisort($weights, SORT_ASC, array_keys($methods), SORT_ASC, $methods);
        return $methods;
    }
1612
protected function getListPayment()
    {
        $id = $this->getParam(0);

        if (!isset($id)) {
            $list = $this->payment->getList();
            $this->limitArray($list);
            return $list;
        }

        $method = $this->payment->get($id);

        if (empty($method)) {
            $this->errorAndExit($this->text('Unexpected result'));
        }

        return array($method);
    }
1183203
public function getInstallments($paymentAmount)
    {
        $installments = [];

        $this->setPaymentAmount($paymentAmount);
        $maxInstallmentQty = $this->getMaximumInstallmentQuantity();

        # Looping through all possible installment values
        for ($curInstallment = 1; ($curInstallment <= 12 && $curInstallment <= $maxInstallmentQty); $curInstallment++) {

            if ($curInstallment === 1) {
                # If this is a one time payment, we use the current value and only one installment, no interest
                $installments[$curInstallment] = $this->_dataObjectFactory->create();
                $installments[$curInstallment]->installmentValue = $paymentAmount;
                $installments[$curInstallment]->numberInstallments = 1;
                $installments[$curInstallment]->interestsApplied = false;

                continue;
            } else {
                $totalAmountAfterInterest = $this->getTotalAmountAfterInterest($curInstallment);
                $amountPerInstallment = $totalAmountAfterInterest / $curInstallment;

                # If the total per installment is less then the minimum installment amount, we won't
                # include this installment
                $minimumInstallmentAmount = $this->getMinimumInstallmentAmount();
                if ($amountPerInstallment < $minimumInstallmentAmount) {
                    continue;
                }

                $installments[$curInstallment] = $this->_dataObjectFactory->create();
                $installments[$curInstallment]->installmentValue = $amountPerInstallment;
                $installments[$curInstallment]->numberInstallments = $curInstallment;
                $installments[$curInstallment]->interestsApplied = $this->isApplyInterest($curInstallment);
            }
        }

        return (array) $installments;
    }
514757
public function getAllSets()
    {
        if ($this->_aAllSets === null) {
            $this->_aAllSets = false;

            if ($this->getPaymentList()) {
                return $this->_aAllSets;
            }
        }

        return $this->_aAllSets;
    }
876758
protected function getPaymentTransactionStructure()
    {
        return [
            'amount'             => $this->transformAmount($this->amount, $this->currency),
            'currency'           => $this->currency,
            'customer_email'     => $this->customer_email,
            'customer_phone'     => $this->customer_phone,
            'holder_name'        => $this->holder_name,
            'iban'               => $this->iban,
            'swift_code'         => $this->swift_code,
            'account_number'     => $this->account_number,
            'bank_name'          => $this->bank_name,
            'bank_city'          => $this->bank_city,
            'bank_code'          => $this->bank_code,
            'branch_code'        => $this->branch_code,
            'branch_check_digit' => $this->branch_check_digit,
            'billing_address'    => $this->getBillingAddressParamsStructure(),
            'shipping_address'   => $this->getShippingAddressParamsStructure()
        ];
    }
1107081
static public function isPaymentMethod($paymentMethod) {
    return ((string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_CREDITCARD ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_TODITOCASH ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_BANKTRANSFER ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_DIRECTDEBIT ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_WECHAT ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_LINE ||
        (string) $paymentMethod == Connect2PayClient::PAYMENT_METHOD_ALIPAY);
  }
157524
private List<PaymentTransactionInfoPlugin> getPaymentTransactionInfoPluginsIfNeeded(@Nullable final PaymentPluginApi pluginApi, final PaymentModelDao paymentModelDao, final TenantContext context) {
        if (pluginApi == null) {
            return null;
        }

        try {
            return getPaymentTransactionInfoPlugins(pluginApi, paymentModelDao, PLUGIN_PROPERTIES, context);
        } catch (final PaymentApiException e) {
            log.warn("Unable to retrieve plugin info for payment " + paymentModelDao.getId());
            return null;
        }
    }
847331
public function paymentMethods()
    {
        $this->integrityCheck();

        $paymentMethods = $this->mpay24Sdk->listPaymentMethods();

        $this->recordedLastMessageExchange("PaymentMethods");

        return $paymentMethods;
    }
85209
protected function getPaymentTransactionStructure()
    {
        return [
            'reference_id' => $this->reference_id,
            'amount'       => $this->transformAmount($this->amount, $this->currency),
            'currency'     => $this->currency
        ];
    }