API - Code Metrics - Inspection of "Add two functions to work with contacts folder" - Garethp/php-ews - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#83)

unknown

created 2017-01-24 11:46 UTC

API B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	557
Duplicated Lines	16.52 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

75.83%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	53
c	1
b	0
f	0
lcom	1
cbo	4
dl	92
loc	557
ccs	182
cts	240
cp	0.7583
rs	7.4757

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getPrimarySmtpMailbox()	0	4	1
A	getCalendar()	0	8	1
A	getMailbox()	0	8	1
A	setClient()	0	6	1
A	getClient()	0	4	1
A	withUsernameAndPassword()	0	9	1
A	withCallbackToken()	0	8	1
A	getPrimarySmptEmailAddress()	0	8	2
A	setPrimarySmtpEmailAddress()	0	6	1
A	createItems()	0	17	2
A	updateItems()	0	23	3
B	createCalendars()	27	27	3
B	createContactsFolder()	27	27	3
B	createFolders()	0	24	3
A	deleteFolder()	0	4	1
A	deleteFolders()	0	20	2
A	moveItem()	0	11	1
B	deleteItems()	0	24	3
A	getFolder()	0	14	1
A	getFolderByDistinguishedId()	0	9	1
A	getFolderByFolderId()	0	6	1
A	getChildrenFolders()	23	23	2
A	getFolderByDisplayName()	0	12	3
A	getItem()	15	15	2
A	listItemChanges()	0	21	2
A	getServerTimezones()	0	19	3
A	convertIdFormat()	0	17	1
A	getNextPage()	0	18	3
A	emptyFolder()	0	16	1

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 API 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 API, and based on these observations, apply Extract Interface, too.

<?php

namespace garethp\ews;

use garethp\ews\API\ExchangeWebServices;
use garethp\ews\API\Message\EmptyFolderResponseType;
use garethp\ews\API\Message\GetServerTimeZonesType;
use garethp\ews\API\Message\SyncFolderItemsResponseMessageType;
use garethp\ews\API\Message\UpdateItemResponseMessageType;
use garethp\ews\API\Type;

/**
 * A base class for APIs
 *
 * Class BaseAPI
 * @package garethp\ews
 */
class API
{
    protected static $defaultClientOptions = array(
        'version' => ExchangeWebServices::VERSION_2010
    );

    public function __construct(ExchangeWebServices $client = null)
    {
        if ($client) {
            $this->setClient($client);
        }
    }

    /**
     * @return Type\EmailAddressType
     */
    public function getPrimarySmtpMailbox()
    {
        return $this->getClient()->getPrimarySmtpMailbox();
    }

    /**
     * Storing the API client
     * @var ExchangeWebServices
     */
    private $client;

    /**
     * Get a calendar item
     *
     * @param string $name
     * @return CalendarAPI
     */
    public function getCalendar($name = null)
    {
        $calendar = new CalendarAPI();
        $calendar->setClient($this->getClient());
        $calendar->pickCalendar($name);

        return $calendar;
    }

    /**
     * @param string $folderName
     * @return MailAPI
     */
    public function getMailbox($folderName = null)
    {
        $mailApi = new MailAPI();
        $mailApi->setClient($this->getClient());
        $mailApi->pickMailFolder($folderName);

        return $mailApi;
    }

    /**
     * Set the API client
     *
     * @param ExchangeWebServices $client
     * @return $this
     */
    public function setClient($client)
    {
        $this->client = $client;

        return $this;
    }

    /**
     * Get the API client
     *
     * @return ExchangeWebServices
     */
    public function getClient()
    {
        return $this->client;
    }

    public static function withUsernameAndPassword($server, $username, $password, $options = [])
    {
        return new static(ExchangeWebServices::fromUsernameAndPassword(
            $server,
            $username,
            $password,
            array_replace_recursive(self::$defaultClientOptions, $options)
        ));
    }

    public static function withCallbackToken($server, $token, $options = [])
    {
        return new static(ExchangeWebServices::fromCallbackToken(
            $server,
            $token,
            array_replace_recursive(self::$defaultClientOptions, $options)
        ));
    }

    public function getPrimarySmptEmailAddress()
    {
        if ($this->getPrimarySmtpMailbox() == null) {
            return null;
        }

        return $this->getPrimarySmtpMailbox()->getEmailAddress();
    }

    public function setPrimarySmtpEmailAddress($emailAddress)
    {
        $this->getClient()->setPrimarySmtpEmailAddress($emailAddress);

        return $this;
    }

    /**
     * Create items through the API client
     *
     * @param $items
     * @param array $options
     * @return Type
     */
    public function createItems($items, $options = array())
    {
        if (!is_array($items)) {
            $items = array($items);
        }

        $request = array(
            'Items' => $items
        );

        $request = array_replace_recursive($request, $options);
        $request = Type::buildFromArray($request);

        $response = $this->getClient()->CreateItem($request);

        return $response;
    }

    public function updateItems($items, $options = array())
    {
        $request = array(
            'ItemChanges' => $items,
            'MessageDisposition' => 'SaveOnly',
            'ConflictResolution' => 'AlwaysOverwrite'
        );

        $request = array_replace_recursive($request, $options);

        $request = Type::buildFromArray($request);

        $response = $this->getClient()->UpdateItem($request);
        if ($response instanceof UpdateItemResponseMessageType) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return $response->getItems();
        }

        if (!is_array($response)) {
            $response = array($response);
        }

        return $response;
    }

    public function createCalendars($names, Type\FolderIdType $parentFolder = null, $options = array())

    {
        if ($parentFolder == null) {
            $parentFolder = $this->getFolderByDistinguishedId('calendar')->getFolderId();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        if (!is_array($names)) {
            $names = array($names);
        }

        $names = array_map(function ($name) {
            return array(
                'DisplayName' => $name,
                'FolderClass' => 'IPF.Appointment'
            );
        }, $names);

        $request = [
            'Folders' => ['Folder' => $names],
            'ParentFolderId' => ['FolderId' => $parentFolder->toArray()]
        ];

        $request = array_merge_recursive($request, $options);

        $this->client->CreateFolder($request);
        return true;
    }
    
    public function createContactsFolder($names, Type\FolderIdType $parentFolder = null, $options = array())

    {
        if ($parentFolder == null) {
            $parentFolder = $this->getFolderByDistinguishedId('contacts')->getFolderId();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        if (!is_array($names)) {
            $names = array($names);
        }

        $names = array_map(function ($name) {
            return array(
                'DisplayName' => $name,
                'FolderClass' => 'IPF.Contact'
            );
        }, $names);

        $request = [
            'Folders' => ['Folder' => $names],
            'ParentFolderId' => ['FolderId' => $parentFolder->toArray()]
        ];

        $request = array_merge_recursive($request, $options);

        $this->client->CreateFolder($request);
        return true;
    }

    public function createFolders($names, Type\FolderIdType $parentFolder, $options = array())
    {
        if (!is_array($names)) {
            $names = array($names);
        }

        $names = array_map(function ($name) {
            return ['DisplayName' => $name];
        }, $names);

        $request = [
            'Folders' => ['Folder' => $names]
        ];

        if (!empty($parentFolder)) {
            $request['ParentFolderId'] = array('FolderId' => $parentFolder->toArray());
        }

        $request = array_merge_recursive($request, $options);

        $this->client->CreateFolder($request);

        return true;
    }

    /**
     * @deprecated Please use API::deleteFolders() instead
     *
     * @param Type\FolderIdType $folderId
     * @param array $options
     * @return Type
     */
    public function deleteFolder(Type\FolderIdType $folderId, $options = array())
    {
        return $this->deleteFolders($folderId, $options);
    }

    public function deleteFolders($folders, $options = array())
    {
        if (!is_array($folders)) {
            $folders = array($folders);
        }

        $folderIds = array_map(function ($folderId) {
            return $folderId->toArray();
        }, $folders);

        $request = [
            'DeleteType' => 'HardDelete',
            'FolderIds' => array(
                'FolderId' => $folderIds
            )
        ];

        $request = array_merge_recursive($request, $options);
        return $this->client->DeleteFolder($request);
    }

    public function moveItem(Type\ItemIdType $itemId, Type\FolderIdType $folderId, $options = array())
    {
        $request = array(
            'ToFolderId' => array('FolderId' => $folderId->toArray()),
            'ItemIds' => array('ItemId' => $itemId->toArray())
        );

        $request = array_merge_recursive($request, $options);

        return $this->client->MoveItem($request);
    }

    /**
     * @param $items Type\ItemIdType|Type\ItemIdType[]
     * @param array $options
     * @return bool
     */
    public function deleteItems($items, $options = array())
    {
        if (!is_array($items) || Type::arrayIsAssoc($items)) {
            $items = array($items);
        }

        $items = array_map(function ($item) {
            $item = Type\ItemIdType::buildFromArray($item);

            return $item->toArray();
        }, $items);

        $request = array(
            'ItemIds' => array('ItemId' => $items),
            'DeleteType' => 'MoveToDeletedItems'
        );

        $request = array_replace_recursive($request, $options);
        $request = Type::buildFromArray($request);
        $this->getClient()->DeleteItem($request);

        //If the delete fails, an Exception will be thrown in processResponse before it gets here
        return true;
    }

    /**
     * @param $identifier
     * @return Type\BaseFolderType
     */
    public function getFolder($identifier)
    {
        $request = array(
            'FolderShape' => array(
                'BaseShape' => array('_' => 'Default')
            ),
            'FolderIds' => $identifier
        );
        $request = Type::buildFromArray($request);

        $response = $this->getClient()->GetFolder($request);

        return $response;
    }

    /**
     * Get a folder by it's distinguishedId
     *
     * @param string $distinguishedId
     * @return Type\BaseFolderType
     */
    public function getFolderByDistinguishedId($distinguishedId)
    {
        return $this->getFolder(array(
            'DistinguishedFolderId' => array(
                'Id' => $distinguishedId,
                'Mailbox' => $this->getPrimarySmtpMailbox()
            )
        ));
    }

    /**
     * @param $folderId
     * @return Type\BaseFolderType
     */
    public function getFolderByFolderId($folderId)
    {
        return $this->getFolder(array(
            'FolderId' => array('Id' => $folderId, 'Mailbox' => $this->getPrimarySmtpMailbox())
        ));
    }

    /**
     * @param string|Type\FolderIdType $parentFolderId
     * @param array $options
     * @return Type\BaseFolderType[]
     */
    public function getChildrenFolders($parentFolderId = 'root', $options = array())

    {
        if (is_string($parentFolderId)) {
            $parentFolderId = $this->getFolderByDistinguishedId($parentFolderId)->getFolderId();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        $request = array(
            'Traversal' => 'Shallow',
            'FolderShape' => array(
                'BaseShape' => 'AllProperties'
            ),
            'ParentFolderIds' => array(
                'FolderId' => $parentFolderId->toArray()
            )
        );

        $request = array_replace_recursive($request, $options);

        $request = Type::buildFromArray($request);

        /** @var \garethp\ews\API\Message\FindFolderResponseMessageType $folders */
        return $this->getClient()->FindFolder($request);
    }

    /**
     * @param string $folderName
     * @param string|Type\FolderIdType $parentFolderId
     * @param array $options
     * @return bool|Type\BaseFolderType
     */
    public function getFolderByDisplayName($folderName, $parentFolderId = 'root', $options = array())
    {
        $folders = $this->getChildrenFolders($parentFolderId, $options);

        foreach ($folders as $folder) {

            if ($folder->getDisplayName() == $folderName) {
                return $folder;
            }
        }

        return false;
    }

    /**
     * @param $itemId array|Type\ItemIdType
     * @param array $options
     * @return Type
     */
    public function getItem($itemId, $options = array())

    {
        if ($itemId instanceof Type\ItemIdType) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            $itemId = $itemId->toArray();
        }

        $request = array(
            'ItemShape' => array('BaseShape' => 'AllProperties'),
            'ItemIds' => array('ItemId' => $itemId)
        );

        $request = array_replace_recursive($request, $options);

        return $this->getClient()->GetItem($request);
    }

    /**
     * Get a list of sync changes on a folder
     *
     * @param Type\FolderIdType $folderId
     * @param null $syncState
     * @param array $options
     * @return SyncFolderItemsResponseMessageType
     */
    public function listItemChanges($folderId, $syncState = null, $options = array())
    {
        $request = array(
            'ItemShape' => array('BaseShape' => 'AllProperties'),
            'SyncFolderId' => array('FolderId' => $folderId->toXmlObject()),
            'SyncScope' => 'NormalItems',
            'MaxChangesReturned' => '100'
        );

        if ($syncState != null) {
            $request['SyncState'] = $syncState;
            $request['ItemShape']['BaseShape'] = 'AllProperties';
        }

        $request = array_replace_recursive($request, $options);

        $request = Type::buildFromArray($request);
        $response = $this->getClient()->SyncFolderItems($request);

        return $response;
    }

    public function getServerTimezones($timezoneIDs = array(), $fullTimezoneData = false)
    {
        $request = GetServerTimeZonesType::buildFromArray(array(
            'returnFullTimeZoneData' => $fullTimezoneData
        ));

        if (!empty($timezoneIDs)) {
            $request->setIds($timezoneIDs);
        }

        $timezones = $this->getClient()->GetServerTimeZones($request);
        $timezones = $timezones->TimeZoneDefinition;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        if (!is_array($timezones)) {
            $timezones = array($timezones);
        }

        return $timezones;
    }

    /**
     * @param Type\ItemIdType $itemId
     * @param $fromType
     * @param $destinationType
     * @param $mailbox
     *
     * @return Type\ItemIdType
     */
    public function convertIdFormat(Type\ItemIdType $itemId, $fromType, $destinationType, $mailbox)
    {
        $result = $this->getClient()->ConvertId(array(
            'DestinationFormat' => $destinationType,
            'SourceIds' => array(
                'AlternateId' => array(
                    'Format' => $fromType,
                    'Id' => $itemId->getId(),
                    'Mailbox' => $mailbox
                )
            )
        ));

        $itemId->setId($result->getId());
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        return $itemId;
    }

    /**
     * @param Type\FindItemParentType|Type\FindFolderParentType $result
     *
     * @return Type\FindItemParentType|Type\FindFolderParentType
     */
    public function getNextPage($result)
    {
        if ($result->isIncludesLastItemInRange()) {
            return $result;
        }

        $currentPage = $result->getCurrentPage();
        $currentPage->setOffset($result->getIndexedPagingOffset());

        $lastRequest = $result->getLastRequest();
        $lastRequest->setIndexedPage($currentPage);

        if ($result instanceof Type\FindFolderParentType) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return $this->getClient()->FindFolder($lastRequest);
        }

        return $this->getClient()->FindItem($lastRequest);
    }

    /**
     * @param Type\FolderIdType $folderId
     * @param string $deleteType
     * @param bool $deleteSubFolders
     * @param array $options
     * @return EmptyFolderResponseType
     */
    public function emptyFolder(
        Type\FolderIdType $folderId,
        $deleteType = 'SoftDelete',
        $deleteSubFolders = false,
        array $options = []
    ) {
        $request = [
            'DeleteType' => $deleteType,
            'DeleteSubFolders' => $deleteSubFolders,
            'FolderIds' => ['FolderId' => $folderId->toArray()]
        ];

        $request = array_merge_recursive($request, $options);

        return $this->getClient()->EmptyFolder($request);
    }
}


Pull Request — master (#83)

API B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

30 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Garethp / php-ews

Pull Request — master (#83)

API B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

30 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like