Issues in LaravelMobilpayController.php (develop) - Issues in develop - stl30/laravel-mobilpay - Measure and Improve Code Quality continuously with Scrutinizer

Issues (37)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

src/Http/Controllers/LaravelMobilpayController.php (22 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Stl30\LaravelMobilpay\Http\Controllers;

use App\LaravelMobilpay\LaravelMobilpayCustomActionsAndNotifications;
use \Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;
use Netopia\Payment\Address;
use Netopia\Payment\Request\Card;
use Netopia\Payment\Request\PaymentAbstract;
use Stl30\LaravelMobilpay\CustomActionsAndNotifications;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Request\Mobilpay_Payment_Request_Abstract;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Request\Mobilpay_Payment_Request_Card;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Invoice;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Mobilpay_Payment_Address;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Request\Mobilpay_Payment_Request_Notify;
use Stl30\LaravelMobilpay\Mobilpay\Payment\Mobilpay_Payment_Invoice;
use Stl30\LaravelMobilpay\MobilpayTransaction;

class LaravelMobilpayController extends Controller
{
    /**
     * @var CustomActionsAndNotifications
     */
    public $actionsAndNotifications;

    public function __construct()
    {
        $this->actionsAndNotifications = new LaravelMobilpayCustomActionsAndNotifications();
    }

    public function card()
    {
        //
        return view('vendor.laravel-mobilpay.card');
    }

    public function addTransaction(Card $mobilpayRequestObject, $customDataParameter = '')
    {
        $this->actionsAndNotifications->setActions([
            'transaction' => 'start create',
            'time' => date('Y-m-d H:i:s')
        ]);

        $this->actionsAndNotifications->beforeCreatingTransaction($mobilpayRequestObject, $customDataParameter);
        $transaction = new MobilpayTransaction();
        $transaction->id_transaction = $mobilpayRequestObject->orderId;
        $transaction->request_status = 0;
        $transaction->status = 'initiated';
        $transaction->value = $mobilpayRequestObject->invoice->amount;
        $transaction->currency = $mobilpayRequestObject->invoice->currency;
        $transaction->details = $mobilpayRequestObject->invoice->details;
        $transaction->type = $mobilpayRequestObject->invoice->getBillingAddress()->type ?? null;
        $transaction->client_name = $mobilpayRequestObject->invoice->getBillingAddress()->firstName ?? null;
        $transaction->client_surname = $mobilpayRequestObject->invoice->getBillingAddress()->lastName ?? null;
        $transaction->client_email = $mobilpayRequestObject->invoice->getBillingAddress()->email ?? null;
        $transaction->client_address = $mobilpayRequestObject->invoice->getBillingAddress()->address ?? null;
        $transaction->client_phone = $mobilpayRequestObject->invoice->getBillingAddress()->mobilePhone ?? null;
        $transaction->client_fiscal_number = $mobilpayRequestObject->invoice->getBillingAddress()->fiscal_number ?? null;
        $transaction->client_identity_number = $mobilpayRequestObject->invoice->getBillingAddress()->identity_number ?? null;
        $transaction->client_country = $mobilpayRequestObject->invoice->getBillingAddress()->country ?? null;
        $transaction->client_county = $mobilpayRequestObject->invoice->getBillingAddress()->county ?? null;
        $transaction->client_city = $mobilpayRequestObject->invoice->getBillingAddress()->city ?? null;
        $transaction->client_zip_code = $mobilpayRequestObject->invoice->getBillingAddress()->zip_code ?? null;
        $transaction->client_bank = $mobilpayRequestObject->invoice->getBillingAddress()->bank ?? null;
        $transaction->client_iban = $mobilpayRequestObject->invoice->getBillingAddress()->iban ?? null;
        $transaction->request_object = json_encode($mobilpayRequestObject, true);
        $transaction->custom_data = $customDataParameter;
        $addTransactionIsSuccessful = $transaction->save();

        if ($addTransactionIsSuccessful) {
            $this->actionsAndNotifications->setNotifications([
                'request_status' => $transaction->request_status,
                'id_transaction_created' => $transaction->id,
            ]);
            $this->actionsAndNotifications->setActions([
                'transaction' => 'successfully created',
            ]);
        }


        $this->actionsAndNotifications->afterCreatingTransaction($transaction, $addTransactionIsSuccessful);

        return $addTransactionIsSuccessful;
    }

    public function updateTransaction(PaymentAbstract $mobilpayReturnObject, $orderStatus = 'possible error')
    {
        $this->actionsAndNotifications->setActions([
            'transaction' => 'start update',
            'time' => date('Y-m-d H:i:s')
        ]);

        $this->actionsAndNotifications->beforeUpdatingTransaction($mobilpayReturnObject, $orderStatus);

        $transaction = MobilpayTransaction::where('id_transaction', '=', $mobilpayReturnObject->orderId)->firstOrFail();
        if (isset($mobilpayReturnObject->objPmNotify->token_id) && strlen($mobilpayReturnObject->objPmNotify->token_id)) {
            $transaction->token_id = $mobilpayReturnObject->objPmNotify->token_id;
            $transaction->token_expiration_date = $mobilpayReturnObject->objPmNotify->token_expiration_date;
        }
        $transaction->value = $mobilpayReturnObject->invoice->amount;
        $transaction->currency = $mobilpayReturnObject->invoice->currency;
        $transaction->details = $mobilpayReturnObject->invoice->details;
        $transaction->request_status = 1;
        $transaction->status = $orderStatus;
        $transaction->client_name = $mobilpayReturnObject->objPmNotify->customer->firstName;
        $transaction->client_surname = $mobilpayReturnObject->objPmNotify->customer->lastName;
        $transaction->client_address = $mobilpayReturnObject->objPmNotify->customer->address;
        $transaction->client_email = $mobilpayReturnObject->objPmNotify->customer->email;
        $transaction->client_phone = $mobilpayReturnObject->objPmNotify->customer->mobilePhone;
        $transaction->return_request_object = json_encode($mobilpayReturnObject, true);
        $updatedIsSuccessful = $transaction->update();

        if ($updatedIsSuccessful) {

            $this->actionsAndNotifications->setNotifications([
                'status' => $transaction->status,
                'request_status' => $transaction->request_status,
                'id_transaction_created' => $transaction->id,
            ]);
            $this->actionsAndNotifications->setActions([
                'transaction' => 'successfully updated',
                'time' => date('Y-m-d H:i:s')
            ]);
        }

        $this->actionsAndNotifications->afterUpdatingTransaction($transaction, $updatedIsSuccessful);

        return $updatedIsSuccessful;
    }

    function addAutomatedTransactionError($errorCode, $errorType, $errorMessage, $mobilpayReturnObject)

    {
        $this->actionsAndNotifications->setActions([
            'error transaction' => 'start creating',
            'time' => date('Y-m-d H:i:s')
        ]);

        $transaction = new MobilpayTransaction();
        $transaction->id_transaction = 'error code:'.$errorCode.'>> error type:'.$errorType.'>> error message:'.$errorMessage;
        $transaction->request_status = $errorType;
        $transaction->request_object = json_encode($mobilpayReturnObject, true);
        $transaction->status = $errorMessage;
        $addTransactionIsSuccessful = $transaction->save();

        if ($addTransactionIsSuccessful) {

            $this->actionsAndNotifications->setNotifications([
                'status' => $transaction->status,
                'request_status' => $transaction->request_status,
            ]);
            $this->actionsAndNotifications->setActions([
                'error transaction' => 'successfully created',
                'time' => date('Y-m-d H:i:s')
            ]);
        }

        $this -> actionsAndNotifications ->onTransactionError($errorCode, $errorType, $errorMessage, $mobilpayReturnObject);

        return $addTransactionIsSuccessful;
    }

    public static function validatePaymentDetails(array $parameters = [])
    {
        $errorsText = [];
        $paymentParameters = [];
        $requiredParameters = [
            #must haves values
            'payment_amount' => 'value of payment',
            'payment_details' => 'payment details placeholder',
            'order_id' => '',
            'billing_type' => 'person',//or company
        ];
        foreach ($requiredParameters as $requiredName => $value) {
            if (isset($parameters[$requiredName]) && $parameters[$requiredName] !== null) {

                $paymentParameters[$requiredName] = $parameters[$requiredName];
                continue;
            }
            $errorsText['errors'][]= 'Missing required parameter '.$requiredName;
        }
        if (count($errorsText)) {
            echo '<pre>';
            var_dump('>>>>>');

            print_r($errorsText);
            echo('</pre>');
            die('>>>>>>>>>>>>>>>>>><<<<<<<<<<');

        }

        $optionalParameters = [
            #custom data / if you need some custom data save on the transactions table
            'custom_data' => '',
            #optional values
            'promotion_code' => '',
            'currency' => '',
            #details on the cardholder address (optional)

            'billing_first_name' => '',//client first name
            'billing_last_name' => '',//client last name
            'billing_address' => '',//client adress
            'billing_email' => '',//client email
            'billing_mobile_phone' => '',//client phone/mobile
            'billing_fiscal_number' => '',
            'billing_identity_number' => '',
            'billing_country' => '',
            'billing_county' => '',
            'billing_city' => '',
            'billing_zip_code' => '',
            'billing_bank' => '',
            'billing_iban' => '',
            #details on the shipping address
            'shipping_type' => 'person',//or company
            'shipping_first_name' => '',
            'shipping_last_name' => '',
            'shipping_address' => '',
            'shipping_email' => '',
            'shipping_mobile_phone' => '',
            'shipping_fiscal_number' => '',
            'shipping_identity_number' => '',
            'shipping_country' => '',
            'shipping_county' => '',
            'shipping_city' => '',
            'shipping_zip_code' => '',
            'shipping_bank' => '',
            'shipping_iban' => '',
        ];


        foreach ($optionalParameters as $key => $Value) {
            if (isset($parameters[$key]) && $parameters[$key] !== null) {

                $paymentParameters[$key] = $parameters[$key];
            }
        }

        return $paymentParameters;
    }

    public function cardRedirect(array $paymentParameters = array(),$returnOnlyData = false)
    {
        $paymentParameters = self::validatePaymentDetails($paymentParameters);

        #for testing purposes, all payment requests will be sent to the sandbox server. Once your account will be active you must switch back to the live server https://secure.mobilpay.ro
        #in order to display the payment form in a different language, simply add the language identifier to the end of the paymentUrl, i.e https://secure.mobilpay.ro/en for English
        if (config('laravel-mobilpay.sandbox_active')) {
            $paymentUrl = config('laravel-mobilpay.sandbox_payment_link');
        } else {
            $paymentUrl = config('laravel-mobilpay.production_payment_link');
        }

        //$paymentUrl = 'https://secure.mobilpay.ro';
        // this is the path on your server to the public certificate. You may download this from Admin -> Conturi de comerciant -> Detalii -> Setari securitate
//        $x509FilePath 	= 'i.e: /home/certificates/public.cer';

        if (!config('laravel-mobilpay.sandbox_active')) {
            $x509FilePath = config('laravel-mobilpay.sandbox_public_key');
        } else {
            $x509FilePath = config('laravel-mobilpay.production_public_key');
        }

        try {
            mt_srand((double)microtime() * 1000000);
            $objPmReqCard = new Card();
            #merchant account signature - generated by mobilpay.ro for every merchant account
            #semnatura contului de comerciant - mergi pe www.mobilpay.ro Admin -> Conturi de comerciant -> Detalii -> Setari securitate
            $objPmReqCard->signature = config('laravel-mobilpay.merchant_account_signature');
            #you should assign here the transaction ID registered by your application for this commercial operation
            #order_id should be unique for a merchant account
            $objPmReqCard->orderId = $paymentParameters['order_id'];
            #below is where mobilPay will send the payment result. This URL will always be called first; mandatory
            $objPmReqCard->confirmUrl = config('laravel-mobilpay.confirmUrl');
            #below is where mobilPay redirects the client once the payment process is finished. Not to be mistaken for a "successURL" nor "cancelURL"; mandatory
            $objPmReqCard->returnUrl = config('laravel-mobilpay.returnUrl');

            #detalii cu privire la plata: moneda, suma, descrierea
            #payment details: currency, amount, description
            $objPmReqCard->invoice = new \Netopia\Payment\Invoice();
            #payment currency in ISO Code format; permitted values are RON, EUR, USD, MDL; please note that unless you have mobilPay permission to
            #process a currency different from RON, a currency exchange will occur from your currency to RON, using the official BNR exchange rate from that moment
            #and the customer will be presented with the payment amount in a dual currency in the payment page, i.e N.NN RON (e.ee EUR)
            $objPmReqCard->invoice->currency = $paymentParameters['currency'] ?? config('laravel-mobilpay.currency');
            $objPmReqCard->invoice->amount = $paymentParameters['payment_amount'];
            #available installments number; if this parameter is present, only its value(s) will be available
            //$objPmReqCard->invoice->installments= '2,3';
            #selected installments number; its value should be within the available installments defined above
            //$objPmReqCard->invoice->selectedInstallments= '3';
            //platile ulterioare vor contine in request si informatiile despre token. Prima plata nu va contine linia de mai jos.
            if ($paymentParameters['token_id'] ?? false) {
                $objPmReqCard->invoice->tokenId = $paymentParameters['token_id'];
            }

            $objPmReqCard->invoice->details = $paymentParameters['payment_details'];

            #detalii cu privire la adresa posesorului cardului
            #details on the cardholder address (optional)
            $billingAddress = new Address();
            $billingAddress->type = $paymentParameters['billing_type']; //should be "person"
            $billingAddress->firstName = $paymentParameters['billing_first_name'] ?? null;
            $billingAddress->lastName = $paymentParameters['billing_last_name'] ?? null;
            $billingAddress->address = $paymentParameters['billing_address'] ?? null;
            $billingAddress->email = $paymentParameters['billing_email'] ?? null;
            $billingAddress->mobilePhone = $paymentParameters['billing_mobile_phone'] ?? null;
            $billingAddress->fiscal_number = $paymentParameters['billing_fiscal_number'] ?? null;

            $billingAddress->identity_number = $paymentParameters['billing_identity_number'] ?? null;

            $billingAddress->country = $paymentParameters['billing_country'] ?? null;

            $billingAddress->county = $paymentParameters['billing_county'] ?? null;

            $billingAddress->city = $paymentParameters['billing_city'] ?? null;

            $billingAddress->zip_code = $paymentParameters['billing_zip_code'] ?? null;

            $billingAddress->bank = $paymentParameters['billing_bank'] ?? null;

            $billingAddress->iban = $paymentParameters['billing_iban'] ?? null;

            $objPmReqCard->invoice->setBillingAddress($billingAddress);

            #detalii cu privire la adresa de livrare
            #details on the shipping address
            $shippingAddress = new Address();
            $shippingAddress->type = $paymentParameters['shipping_type'] ?? null;
            $shippingAddress->firstName = $paymentParameters['shipping_first_name'] ?? null;
            $shippingAddress->lastName = $paymentParameters['shipping_last_name'] ?? null;
            $shippingAddress->address = $paymentParameters['shipping_address'] ?? null;
            $shippingAddress->email = $paymentParameters['shipping_email'] ?? null;
            $shippingAddress->mobilePhone = $paymentParameters['shipping_mobile_phone'] ?? null;
            $objPmReqCard->invoice->setShippingAddress($shippingAddress);

            #uncomment the line below in order to see the content of the request
            // TODO for debug
//            dd(__METHOD__,$objPmReqCard,$objPmReqCard->signature,$objPmReqCard->orderId,get_class($objPmReqCard->invoice));
//            echo "<pre>";print_r($objPmReqCard);echo "</pre>";
            $objPmReqCard->encrypt($x509FilePath);
            $customDataForTransaction = $paymentParameters['custom_data'] ?? '';
            $this->addTransaction($objPmReqCard, $customDataForTransaction);
        } catch (\Exception $e) {
            $exception = isset($e) ? $e : null;
        }
        $exception = isset($exception) ? $exception : null;
        //
        if($returnOnlyData == true) {

            return [
                'paymentUrl' => $paymentUrl,
                'env_key' => $objPmReqCard->getEnvKey(),
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                'data' => $objPmReqCard->getEncData(),
                'exception' => $exception,
                #uncomment the line below in order to see the content of the object created
//                'objPmReqCard' => $objPmReqCard,
            ];
        }
        return view('vendor.laravel-mobilpay.cardRedirect')->with([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            'env_key' => $objPmReqCard->getEnvKey(),
            'data' => $objPmReqCard->getEncData(),
            'objPmReqCard' => $objPmReqCard,
            'e' => $exception,
            'paymentUrl' => $paymentUrl
        ]);
    }

    public function cardConfirm()
    {
        $errorCode = 0;
        $errorType = PaymentAbstract::CONFIRM_ERROR_TYPE_NONE;
        $errorMessage = '';
        $orderStatus = '';
        if (strcasecmp($_SERVER['REQUEST_METHOD'], 'post') == 0) {
            if (isset($_POST['env_key']) && isset($_POST['data'])) {
                #calea catre cheia privata
                #cheia privata este generata de mobilpay, accesibil in Admin -> Conturi de comerciant -> Detalii -> Setari securitate
                $privateKeyFilePath = config('laravel-mobilpay.sandbox_private_key');

                try {
                    $objPmReq = PaymentAbstract::factoryFromEncrypted($_POST['env_key'], $_POST['data'], $privateKeyFilePath);
//                    Log::debug('Obiect venit pe confirm url:'.json_encode($objPmReq,true),json_encode($objPmReq,true));
                    #uncomment the line below in order to see the content of the request
                    //print_r($objPmReq);
                    $rrn = $objPmReq->objPmNotify->rrn;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                    // action = status only if the associated error code is zero
                    if ($objPmReq->objPmNotify->errorCode == 0) {
                        switch ($objPmReq->objPmNotify->action) {
                            #orice action este insotit de un cod de eroare si de un mesaj de eroare. Acestea pot fi citite folosind $cod_eroare = $objPmReq->objPmNotify->errorCode; respectiv $mesaj_eroare = $objPmReq->objPmNotify->errorMessage;
                            #pentru a identifica ID-ul comenzii pentru care primim rezultatul platii folosim $id_comanda = $objPmReq->orderId;
                            case 'confirmed':
                                #cand action este confirmed avem certitudinea ca banii au plecat din contul posesorului de card si facem update al starii comenzii si livrarea produsului
                                //update DB, SET status = "confirmed/captured"
                                $orderStatus = 'confirmed/captured';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            case 'confirmed_pending':
                                #cand action este confirmed_pending inseamna ca tranzactia este in curs de verificare antifrauda. Nu facem livrare/expediere. In urma trecerii de aceasta verificare se va primi o noua notificare pentru o actiune de confirmare sau anulare.
                                //update DB, SET status = "pending"
                                $orderStatus = 'pending';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            case 'paid_pending':
                                #cand action este paid_pending inseamna ca tranzactia este in curs de verificare. Nu facem livrare/expediere. In urma trecerii de aceasta verificare se va primi o noua notificare pentru o actiune de confirmare sau anulare.
                                //update DB, SET status = "pending"
                                $orderStatus = 'pending';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            case 'paid':
                                #cand action este paid inseamna ca tranzactia este in curs de procesare. Nu facem livrare/expediere. In urma trecerii de aceasta procesare se va primi o noua notificare pentru o actiune de confirmare sau anulare.
                                //update DB, SET status = "open/preauthorized"
                                $orderStatus = 'open/preauthorized';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            case 'canceled':
                                #cand action este canceled inseamna ca tranzactia este anulata. Nu facem livrare/expediere.
                                //update DB, SET status = "canceled"
                                $orderStatus = 'canceled';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            case 'credit':
                                #cand action este credit inseamna ca banii sunt returnati posesorului de card. Daca s-a facut deja livrare, aceasta trebuie oprita sau facut un reverse.
                                //update DB, SET status = "refunded"
                                $orderStatus = 'refunded';
                                $errorMessage = $objPmReq->objPmNotify->errorMessage;
                                break;
                            default:
                                $errorType = PaymentAbstract::CONFIRM_ERROR_TYPE_PERMANENT;
                                $errorCode = PaymentAbstract::ERROR_CONFIRM_INVALID_ACTION;
                                $orderStatus = $errorMessage = __('mobilpay_refference_action paramaters is invalid');
                                break;
                        }
                    } else {
                        //update DB, SET status = "rejected"
                        $orderStatus = 'rejected';
                        $errorMessage = $objPmReq->objPmNotify->errorMessage;
                    }
                } catch (Exception $e) {
                    $errorType = PaymentAbstract::CONFIRM_ERROR_TYPE_TEMPORARY;
                    $errorCode = $e->getCode();
                    $orderStatus = $errorMessage = $e->getMessage();
                }
            } else {

                $errorType = PaymentAbstract::CONFIRM_ERROR_TYPE_PERMANENT;
                $errorCode = PaymentAbstract::ERROR_CONFIRM_INVALID_POST_PARAMETERS;
                $orderStatus = $errorMessage = __('mobilpay.ro posted invalid parameters');
            }
        } else {

            $errorType = PaymentAbstract::CONFIRM_ERROR_TYPE_PERMANENT;
            $errorCode = PaymentAbstract::ERROR_CONFIRM_INVALID_POST_METHOD;
            $orderStatus = $errorMessage = __('invalid request method for payment confirmation');
        }

        header('Content-type: application/xml');
        echo "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
        if ($errorCode == 0) {
            $updateTransaction = $this->updateTransaction($objPmReq, $orderStatus);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            if ($updateTransaction !== true) {
//                Log::debug('Could not update transaction <<>> ' . json_encode($objPmReq, true) . ' <<<>>> with orderStatus:' . $orderStatus);
            } else {
//                Log::debug('Update transaction success <<>> ' . json_encode($objPmReq, true) . ' <<<>>> with orderStatus:' . $orderStatus);
            }
//            Log::debug('No errors');
//            Log::debug(json_encode($errorMessage, true));
            echo "<crc>{$errorMessage}</crc>";
        } else {
            $objPmReq = (isset($objPmReq) && is_object($objPmReq)) ? $objPmReq : '';
            if ($this->addAutomatedTransactionError($errorCode, $errorType, $errorMessage, $objPmReq) !== true) {
                Log::debug('Could not addAutomatedTransactionError <<>> errortype:'.$errorType.'<<<>>> error code:'.$errorCode.'<<<<>>>'.json_encode($errorMessage, true));
            } else {
//                Log::debug('addedAutomatedTransactionError <<>> errortype:' . $errorType . '<<<>>> error code:' . $errorCode . '<<<<>>>' . json_encode($errorMessage, true));
            }
//            Log::debug('With errors');
//            Log::debug('errortype:' . $errorType . '<<<>>> error code:' . $errorCode . '<<<<>>>' . json_encode($errorMessage, true));
            echo "<crc error_type=\"{$errorType}\" error_code=\"{$errorCode}\">{$errorMessage}</crc>";
        }
    }

    public function cardReturn(Request $request)
    {
        $orderStatus = 'eroare';
        $orderId = (isset($request->orderId) && $request->orderId !== null) ? $request->orderId : '';
        $order = MobilpayTransaction::where('id_transaction', '=', $request->orderId)->first();
        if ($order !== null) {
            switch ($order->status) {
                case 'confirmed/captured':
                    $orderStatus = 'succes';
                    break;
                case 'rejected':
                    $orderStatus = 'rejected';
                    break;
                case 'pending':
                    $orderStatus = 'pending';
                    break;
                default:
                    $orderStatus = 'error';
                    break;
            }
        }

        return view('vendor.laravel-mobilpay.cardReturn')->with([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            'orderId' => $orderId,
            'orderStatus' => $orderStatus
        ]);
    }
}


Issues (37)

Security Analysis not enabled

src/Http/Controllers/LaravelMobilpayController.php (22 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

stl30 / laravel-mobilpay

Issues (37)

Security Analysis not enabled

src/Http/Controllers/LaravelMobilpayController.php (22 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like