Smsa - Code Metrics - Inspection of "Dev" - alhoqbani/smsa-webservice - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Hamoud

created 2018-04-30 21:57 UTC

Smsa B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	513
Duplicated Lines	25.73 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

Metric	Value
wmc	44
lcom	1
cbo	14
dl	132
loc	513
rs	8.3396
c	0
b	0
f	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	1
A	cities()	16	16	2
A	retailsIn()	16	16	2
A	retails()	16	16	2
B	track()	0	28	4
A	trackByReference()	0	22	3
B	status()	26	26	5
B	cancel()	26	26	5
A	createShipment()	0	20	3
A	awbPDF()	0	18	2
A	parseCityResult()	0	14	2
A	parseRetailsResult()	0	21	3
A	parseTrackResult()	0	19	2
A	successResponse()	14	14	1
A	failedRequest()	0	21	2
A	failedResponse()	18	18	2
A	shouldUseExceptions()	0	4	1
A	throwRequestError()	0	11	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Smsa often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Smsa, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of Smsa WebService package.
 * (c) Hamoud Alhoqbani <[email protected]>
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Alhoqbani\SmsaWebService;

use Alhoqbani\SmsaWebService\Exceptions\FailedResponse;
use Alhoqbani\SmsaWebService\Exceptions\RequestError;
use Alhoqbani\SmsaWebService\Models\Shipment;
use Alhoqbani\SmsaWebService\Response\SMSAResponse;
use Alhoqbani\SmsaWebService\Soap\ClassMap;
use Alhoqbani\SmsaWebService\Soap\Service;
use Alhoqbani\SmsaWebService\Soap\Type\CancelShipment;
use Alhoqbani\SmsaWebService\Soap\Type\GetAllRetails;
use Alhoqbani\SmsaWebService\Soap\Type\GetPDF;
use Alhoqbani\SmsaWebService\Soap\Type\GetRTLCities;
use Alhoqbani\SmsaWebService\Soap\Type\GetRTLRetails;
use Alhoqbani\SmsaWebService\Soap\Type\GetStatus;
use Alhoqbani\SmsaWebService\Soap\Type\GetTrackingByRef;
use Alhoqbani\SmsaWebService\Soap\Type\GetTrackingwithRef;
use WsdlToPhp\PackageBase\AbstractSoapClientBase;
use WsdlToPhp\PackageBase\AbstractStructBase;

class Smsa
{

    /**
     * Weather to throw exceptions when there is a request error or a failed response from SMSA.
     *
     * @var bool
     */
    public $shouldUseExceptions = true;

    /**
     * @var \Alhoqbani\SmsaWebService\Soap\Service
     */
    protected $service;

    /**
     * @var string
     */
    private $passKey;

    /**
     * Create a new Smsa Instance
     *
     * @param string                 $passKey The pass key to the api provided by Smsa.
     * @param array|null             $options WSDL option to be passed to SoapClient.
     * @param AbstractSoapClientBase $service The service which provide SMSA api methods.
     */
    public function __construct(
        string $passKey = 'Testing0',
        array $options = [],
        AbstractSoapClientBase $service = null
    ) {
        $this->passKey = $passKey;

        $options = array_merge([
            AbstractSoapClientBase::WSDL_URL      => 'http://track.smsaexpress.com/SECOM/SMSAwebService.asmx?WSDL',
            AbstractSoapClientBase::WSDL_CLASSMAP => ClassMap::get(),
        ], $options);

        $this->service = $service ?? new Service($options);
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
    }

    /**
     * Fetch all cities that has SMSAExpress locations
     *
     * @throws RequestError
     *
     * @return SMSAResponse with array of cities with their route code.
     */
    public function cities(): SMSAResponse

    {
        $result = $this->service->getRTLCities(
            $payload = new GetRTLCities($this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('getRTLCities', $payload);
        }

        return $this->successResponse(
            'getRTLCities',
            $payload,
            $this->parseCityResult($result->getGetRTLCitiesResult()->getAny())
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.
}
        );
    }

    /**
     * Fetch all retails in a particular city.
     * The city code is the three letters route code
     * For example: RUH, JED
     *
     * @param $cityCode
     *
     * @throws RequestError
     *
     * @return SMSAResponse with array of retails in given city.
     */
    public function retailsIn($cityCode): SMSAResponse

    {
        $result = $this->service->getRTLRetails(
            $payload = new GetRTLRetails($cityCode, $this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('getRTLCities', $payload);
        }

        return $this->successResponse(
            'getRTLCities',
            $payload,
            $this->parseRetailsResult($result->getGetRTLRetailsResult()->getAny())
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.
}
        );
    }

    /**
     * Fetch all Smsa Express retails
     *
     * @throws RequestError
     *
     * @return SMSAResponse with list of all retails with details
     */
    public function retails(): SMSAResponse

    {
        $result = $this->service->getAllRetails(
            $payload = new GetAllRetails($this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('getAllRetails', $payload);
        }

        return $this->successResponse(
            'getAllRetails',
            $payload,
            $this->parseRetailsResult($result->getGetAllRetailsResult()->getAny())
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.
}
        );
    }

    /**
     * Track a shipment by its awb
     *
     * @param $awb
     *
     * @throws \Alhoqbani\SmsaWebService\Exceptions\RequestError
     * @throws \Alhoqbani\SmsaWebService\Exceptions\FailedResponse
     *
     * @return SMSAResponse
     */
    public function track($awb): SMSAResponse
    {
        $result = $this->service->getTrackingwithRef(
            $payload = new GetTrackingwithRef($awb, $this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('GetTrackingwithRef', $payload);
        }

        $result = $result->getGetTrackingwithRefResult();
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.
}

        if (is_null($result)) {
            return $this->failedResponse('GetTrackingwithRef', $payload, 'The awb provided is not correct.');
        }

        $track = $this->parseTrackResult($result->getAny());

        if (empty($track)) {
            return $this->failedResponse('GetTrackingwithRef', $payload, 'No shipment with provided awb.');
        }

        return $this->successResponse(
            'GetTrackingwithRef',
            $payload,
            $track
        );
    }

    /**
     * Get the real-time tracking information of the shipment
     *
     * @param string $reference Customer reference number
     *
     * @todo This is not working
     *
     * @throws FailedResponse
     * @throws RequestError
     *
     * @return SMSAResponse
     */
    public function trackByReference(string $reference)
    {
        $result = $this->service->getTrackingByRef(
            $payload = new GetTrackingByRef($reference, $this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('GetTrackingwithRef', $payload);
        }

        $data = $result->getGetTrackingByRefResult();
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.
}

        if (is_null($data)) {
            return $this->failedResponse('GetTrackingwithRef', $payload, 'Shipment was not found');
        }

        return $this->successResponse(
            'GetTrackingwithRef',
            $payload,
            $data->getAny()
        );
    }

    /**
     * @param $awb
     *
     * @throws FailedResponse
     * @throws RequestError
     *
     * @return SMSAResponse
     */
    public function status($awb): SMSAResponse

    {
        $result = $this->service->getStatus(
            $payload = new GetStatus($awb, $this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('GetStatus', $payload);
        }

        $status = $result->getGetStatusResult();
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.
}

        if (empty($status) || is_null($status)) {
            return $this->failedResponse('GetStatus', $payload, 'No status, shipment was not found');
        }

        if (0 === strpos(mb_strtolower($status), 'failed')) {
            return $this->failedResponse('GetStatus', $payload, $status);
        }

        return $this->successResponse(
            'GetStatus',
            $payload,
            $status
        );
    }

    /**
     * Cancel a shipment by AWB
     *
     * @param $awb string
     * @param $reason string
     *
     * @throws FailedResponse
     * @throws RequestError
     *
     * @return SMSAResponse
     */
    public function cancel($awb, $reason): SMSAResponse

    {
        $result = $this->service->cancelShipment(
            $payload = new CancelShipment($awb, $this->passKey, $reason)
        );

        if (false === $result) {
            return $this->failedRequest('CancelShipment', $payload);
        }

        $data = $result->getCancelShipmentResult();
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.
}

        if (empty($data) || is_null($data)) {
            return $this->failedResponse('CancelShipment', $payload, 'Cannot Cancel, shipment was not found');
        }

        if (0 === strpos(mb_strtolower($data), 'failed')) {
            return $this->failedResponse('CancelShipment', $payload, $data);
        }

        return $this->successResponse(
            'CancelShipment',
            $payload,
            $data
        );
    }

    /**
     * Create a new shipment
     *
     * @param Shipment $shipment
     *
     * @throws FailedResponse
     * @throws RequestError
     *
     * @return SMSAResponse
     */
    public function createShipment(Shipment $shipment): SMSAResponse
    {
        $payload = $shipment->getTypeObject($this->passKey);

        $method = $shipment->getServiceMethod();

        $result = call_user_func([$this->service, $method], $payload);

        if (false === $result) {
            return $this->failedRequest($method, $payload);
        }

        $data = $result->{"get{$method}Result"}();

        if (0 === strpos(mb_strtolower($data), 'failed')) {
            return $this->failedResponse($method, $payload, $data);
        }

        return $this->successResponse($method, $payload, $data);
    }

    /**
     * Get AWB in PDF for printing
     * This method can be used to get the AWB Copy in PDF format for printing and labeling on shipment.
     *
     * @param $awb string
     *
     * @throws RequestError
     *
     * @return SMSAResponse
     */
    public function awbPDF(string $awb): SMSAResponse
    {
        $result = $this->service->getPDF(
            $payload = new GetPDF($awb, $passKey ?? $this->passKey)
        );

        if (false === $result) {
            return $this->failedRequest('GetPDF', $payload);
        }

        $data = $result->getGetPDFResult();
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.
}

        return $this->successResponse(
            'GetPDF',
            $payload,
            $data
        );
    }

    /**
     * Parse the cities xml response into array
     *
     * @param string $citiesResult
     *
     * @return array Array of cities with its names and route code
     */
    protected function parseCityResult(string $citiesResult): array
    {
        $xml = simplexml_load_string($citiesResult);
        $cities = [];

        foreach ($xml->NewDataSet[0]->RetailCities as $city) {
            $cities[] = [
                'name'      => (string) $city->rCity,
                'routeCode' => (string) $city->routCode,
            ];
        }

        return $cities;
    }

    /**
     * Parse retails xml response into an array
     *
     * @param string $retailsResult
     *
     * @return array array of retails with their details
     */
    private function parseRetailsResult(string $retailsResult): array
    {
        $xml = simplexml_load_string($retailsResult);
        $retails = [];

        if ($xml->count() > 0) {
            foreach ($xml->NewDataSet[0]->RetailsList as $retail) {
                $retails[] = [
                    'code'       => (string) $retail->rCode,
                    'route_code' => (string) $retail->routCode,
                    'city'       => (string) $retail->rCity,
                    'address_en' => (string) $retail->rAddrEng,
                    'address_ar' => (string) $retail->rAddrAr,
                    'gps_point'  => (string) $retail->rGPSPt,
                    'phone'      => (string) $retail->rPhone,
                ];
            }
        }

        return $retails;
    }

    /**
     * Parse a tracking xml response
     *
     * @param string $result
     *
     * @return array Details of the tracking
     */
    private function parseTrackResult(string $result): array
    {
        $xml = simplexml_load_string($result);

        if ($xml->count() > 0) {
            $track = $xml->NewDataSet[0]->Tracking;

            return [
                'awb'       => (string) $track->awbNo,
                'date'      => (string) $track->Date,
                'activity'  => (string) $track->Activity,
                'details'   => (string) $track->Details,
                'location'  => (string) $track->Location,
                'reference' => (string) $track->refNo,
            ];
        }

        return [];
    }

    /**
     * Return a successful response with the data.
     *
     * @param $type string The type/function of the SOAP Api used.
     * @param $payload AbstractStructBase The object that was sent to the SoapClient
     * @param $data mixed
     *
     * @return SMSAResponse
     */
    protected function successResponse($type, $payload, $data): SMSAResponse

    {
        $response = new SMSAResponse(
            true,
            $data,
            null,
            $type,
            $payload,
            $this->service->getLastRequest(true),
            $this->service->getLastResponse(true)
        );

        return $response;
    }

    /**
     * Send a Response with failed request.
     *
     * @param $type string The type/function of the SOAP Api used.
     * @param $payload AbstractStructBase The object that was sent to the SoapClient
     *
     * @throws \Alhoqbani\SmsaWebService\Exceptions\RequestError
     *
     * @return SMSAResponse
     */
    protected function failedRequest($type, $payload)
    {
        $errors = $this->service->getLastError();
        $error = array_shift($errors);

        $response = new SMSAResponse(
            false,
            null,
            $error,
            $type,
            $payload,
            $this->service->getLastRequest(true),
            $this->service->getLastResponse(true)
        );

        if ($this->shouldUseExceptions()) {
            $this->throwRequestError($response);
        }

        return $response;
    }

    /**
     * Return a failed response. (Usually, wrong data was sent to SMSA Api)
     *
     * @param $type string The type/function of the SOAP Api used
     * @param $payload AbstractStructBase The object that was sent to the SoapClient
     * @param $error string The error message from SMSA.
     *
     * @throws FailedResponse
     *
     * @return SMSAResponse
     */
    protected function failedResponse($type, $payload, $error)

    {
        $response = new SMSAResponse(
            false,
            null,
            $error,
            $type,
            $payload,
            $this->service->getLastRequest(true),
            $this->service->getLastResponse(true)
        );

        if ($this->shouldUseExceptions()) {
            throw new FailedResponse($response, $error);
        }

        return $response;
    }

    protected function shouldUseExceptions()
    {
        return $this->shouldUseExceptions;
    }

    /**
     * To handle response error from Smsa Soap server
     *
     * @param SMSAResponse $response
     *
     * @throws RequestError
     */
    protected function throwRequestError(SMSAResponse $response): void
    {
        $errors = $this->service->getLastError();
        $soapFault = array_shift($errors);

        if ($soapFault instanceof \SoapFault) {
            throw new RequestError($response, $soapFault->faultstring, $soapFault->getCode(), $soapFault);

        }

        throw new RequestError($response, 'Smsa request failed with unknown error');
    }
}


Pull Request — master (#1)

Smsa B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

alhoqbani / smsa-webservice

Pull Request — master (#1)

Smsa B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like