API::moveItem() - Code Metrics - Inspection of "Improved how values are handled in update function..." - Garethp/php-ews - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 54cc50...0eced0 )

by Gareth
created 2016-05-10 10:20 UTC
API::moveItem() A

↳ Parent: API
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	6
Duplication

Lines	11
Ratio	100 %
Code Coverage

Tests	0
CRAP Score	2
Metric	Value
dl	11
loc	11
ccs	0
cts	6
cp	0
rs	9.4285
cc	1
eloc	6
nc	1
nop	3
crap	2
<?php

namespace garethp\ews;

use garethp\ews\API\Enumeration\DictionaryURIType;
use garethp\ews\API\Enumeration\UnindexedFieldURIType;
use garethp\ews\API\Exception\ExchangeException;
use garethp\ews\API\ExchangeWebServices;
use garethp\ews\API\Message\GetServerTimeZonesType;
use garethp\ews\API\Message\SyncFolderItemsResponseMessageType;
use garethp\ews\API\Type;
use garethp\ews\Calendar\CalendarAPI;
use garethp\ews\Mail\MailAPI;

/**
 * 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();
    }

    private $unIndexedFieldUris = array();
    private $dictionaryFieldUris = array();

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

    /**
     * @param $className
     * @return array
     */
    public function getFieldUrisFromClass($className)
    {
        //So, since we have to pass in URI's of everything we update, we need to fetch them
        $reflection = new \ReflectionClass($className);
        $constants = $reflection->getConstants();
        $constantsFound = array();

        //Loop through all URI's to list them in an array
        foreach ($constants as $constant) {
            $exploded = explode(":", $constant);
            if (count($exploded) == 1) {
                $exploded = ['item', $exploded[0]];
            }

            $name = strtolower($exploded[1]);
            $category = strtolower($exploded[0]);

            if (!isset($constantsFound[$name])) {
                $constantsFound[$name] = array();
            }
            if (count($exploded) == 3) {
                $entry = strtolower($exploded[2]);
                if (!isset($constantsFound[$name])) {
                    $constantsFound[$name][$category] = array();
                }

                $constantsFound[$name][$category][$entry] = $constant;
            } else {
                $constantsFound[$name][$category] = $constant;
            }
        }

        return $constantsFound;
    }

    public function setupFieldUris()
    {
        $this->unIndexedFieldUris = $this
            ->getFieldUrisFromClass(UnindexedFieldURIType::class);

        $this->dictionaryFieldUris = $this
            ->getFieldUrisFromClass(DictionaryURIType::class);
    }

    public function getFieldUriByName($fieldName, $preference = 'item')
    {
        $fieldName = strtolower($fieldName);
        $preference = strtolower($preference);

        if (empty($this->unIndexedFieldUris)) {
            $this->setupFieldUris();
        }

        if (!isset($this->unIndexedFieldUris[$fieldName])) {
            return false;
        }

        if (!isset($this->unIndexedFieldUris[$fieldName][$preference])) {
            $preference = 'item';
        }

        if (!isset($this->unIndexedFieldUris[$fieldName][$preference])) {
            throw new ExchangeException("Could not find uri $preference:$fieldName");
        }

        return $this->unIndexedFieldUris[$fieldName][$preference];
    }

    public function getIndexedFieldUriByName($fieldName, $preference = 'item', $entryKey = false)
    {
        $fieldName = strtolower($fieldName);
        $preference = strtolower($preference);

        if (empty($this->dictionaryFieldUris)) {
            $this->setupFieldUris();
        }

        if (!isset($this->dictionaryFieldUris[$fieldName])) {
            return false;
        }

        if (!isset($this->dictionaryFieldUris[$fieldName][$preference])) {
            $preference = 'item';
        }

        if (!isset($this->dictionaryFieldUris[$fieldName][$preference])) {
            throw new ExchangeException("Could not find uri $preference:$fieldName");
        }

        $fieldUri = $this->dictionaryFieldUris[$fieldName][$preference];
        if (is_array($fieldUri)) {
            if (!$entryKey) {
                throw new ExchangeException("Please enter a specific entry key for this fieldURI");
            }

            $entryKey = strtolower($entryKey);
            if (!isset($fieldUri[$entryKey])) {
                throw new ExchangeException("Could not find uri $preference:$fieldName:$entryKey");
            }

            $fieldUri = $fieldUri[$entryKey];
        }

        return $fieldUri;
    }

    /**
     * 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;
    }

    /**
     * Instantiate and set a client (ExchangeWebServices) based on the parameters given
     *
     * @deprecated Since 0.6.3
     * @param $server
     * @param $username
     * @param $password
     * @param array $options
     * @return $this
     */
    public function buildClient(
        $server,
        $username,
        $password,
        $options = [ ]
    ) {
        $this->setClient(ExchangeWebServices::fromUsernameAndPassword(
            $server,
            $username,
            $password,
            array_replace_recursive(self::$defaultClientOptions, $options)
        ));
    }

    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 API\CreateItemResponseType
     */
    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);

        return $this->getClient()->UpdateItem($request)->getItems();
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 { }
    }

    protected function getFieldURI($uriType, $key = null, $value = null)
    {
        if (strpos($key, ':') !== false) {
            try {
                $fieldUriValue = substr($key, 0, strpos($key, ':'));

                list ($key, $index) = explode(':', $key);

                if (is_array($value)) {
                    $key = key($value);
                    $value = $value[$key];
                }

                if (is_array($value) && !empty($value['Entry']) && is_array($value['Entry'])) {
                    $entryKey = $value['Entry']['Key'];
                    unset($value['Entry']['Key']);
                    reset($value['Entry']);

                    $fieldKey = key($value['Entry']);
                    $value['Entry']['Key'] = $entryKey;
                    $fieldUri = $this->getIndexedFieldUriByName($fieldUriValue, $uriType, $fieldKey);
                } else {
                    $fieldUri = $this->getIndexedFieldUriByName($fieldUriValue, $uriType);
                }

                return ['IndexedFieldURI', ['FieldURI' => $fieldUri, 'FieldIndex' => $index], $key, $value];
            } catch (\Exception $e) {

            }
        }

        $fullName = $this->getFieldUriByName($key, $uriType);
        return ['FieldURI', ['FieldURI' => $fullName], $key, $value];
    }

    protected function buildUpdateItemChanges($itemType, $uriType, $changes)
    {
        $setItemFields = array();
        $deleteItemFields = array();

        if (isset($changes['deleteFields'])) {
            foreach ($changes['deleteFields'] as $key) {
                list($fieldUriType, $fieldKey) = $this->getFieldURI($uriType, $key);
                $deleteItemFields[] = [$fieldUriType => $fieldKey];
            }

            unset($changes['deleteFields']);
        }

        //Add each property to a setItemField
        foreach ($changes as $key => $valueArray) {
            $valueArray = $this->splitDictionaryUpdateEntries($valueArray);
            if (!is_array($valueArray) || Type::arrayIsAssoc($valueArray)) {
                $valueArray = array($valueArray);
            }

            foreach ($valueArray as $value) {
                list ($fieldUriType, $fieldKey, $valueKey, $value) = $this->getFieldURI($uriType, $key, $value);
                $setItemFields[] = array(
                    $fieldUriType => $fieldKey,
                    $itemType => [$valueKey => $value]
                );
            }
        }

        return array('SetItemField' => $setItemFields, 'DeleteItemField' => $deleteItemFields);
    }

    protected function splitDictionaryUpdateEntries($value)
    {
        if (!is_array($value)) {
            return $value;
        }

        reset($value);
        $fieldKey = key($value);

        if (!is_array($value[$fieldKey]) || empty($value[$fieldKey]['Entry'])) {
            return $value;
        }

        $entryKey = $value[$fieldKey]['Entry']['Key'];
        unset($value[$fieldKey]['Entry']['Key']);

        $newValue = [];
        foreach ($value[$fieldKey]['Entry'] as $key => $updateValue) {
            $newValue[] = [$fieldKey => ['Entry' => ['Key' => $entryKey, $key => $updateValue ]]];
        }

        $value = $newValue;

        return $value;
    }

    public function createFolders($names, Type\FolderIdType $parentFolder, $options = array())
    {
        $request = array('Folders' => array('Folder' => array()));
        if (!empty($parentFolder)) {
            $request['ParentFolderId'] = array('FolderId' => $parentFolder->toArray());
        }

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

        foreach ($names as $name) {
            $request['Folders']['Folder'][] = array(
                'DisplayName' => $name
            );
        }

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

        $this->client->CreateFolder($request);
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 true;
    }

    public function deleteFolder(Type\FolderIdType $folderId, $options = array())

    {
        $request = array(
            'DeleteType' => 'HardDelete',
            'FolderIds' => array(
                'FolderId' => $folderId->toArray()
            )
        );

        $request = array_merge_recursive($request, $options);
        return $this->client->DeleteFolder($request);
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 { }
    }

    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);
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 { }
    }

    /**
     * @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);
        }

        $itemIds = array();
        foreach ($items as $item) {
            if ($item instanceof Type\ItemIdType) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
                $item = $item->toArray();
            }
            $item = (array) $item;
            $itemIds[] = array(
                'Id' => $item['Id'],
                'ChangeKey' => $item['ChangeKey']
            );
        }

        $request = array(
            'ItemIds' => array('ItemId' => $itemIds),
            '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 bool|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);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        return $folders->getFolders();
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
    }

    /**
     * @param $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) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            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' => 'IdOnly'),
            'SyncFolderId' => array('FolderId' => $folderId->toXmlObject()),
            'SyncScope' => 'NormalItems',
            'MaxChangesReturned' => '10'
        );

        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);
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 { }
        $timezones = $timezones->TimeZoneDefinition;

        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(
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 { }
            'DestinationFormat' => $destinationType,
            'SourceIds' => array (
                'AlternateId' => array(
                    'Format' => $fromType,
                    'Id' => $itemId->getId(),
                    'Mailbox' => $mailbox
                )
            )
        ));

        $itemId->setId($result->getId());

        return $itemId;
    }
}

Push — master ( 54cc50...0eced0 )

API::moveItem() A

Complexity

Size

Duplication

Code Coverage

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Garethp / php-ews

Push — master ( 54cc50...0eced0 )

API::moveItem() A

Complexity

Size

Duplication

Code Coverage

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like
