Wabel\Zoho\CRM\AbstractZohoDao

Complexity

Total Complexity

33

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
	getModule()	0	1	?
	getSingularModuleName()	0	1	?
	getPluralModuleName()	0	1	?
	getBeanClassName()	0	1	?
	getFieldsDetails()	0	1	?
A	getZohoClient()	0	4	1
A	getFields()	0	8	1
A	getZCRMModule()	0	4	1
A	getBeansFromZCRMRecords()	0	17	2
A	delete()	0	15	1
A	getById()	0	8	1
A	getRecords()	0	15	3
A	getDeletedRecordIds()	0	4	1
B	createOrUpdate()	0	44	8
A	insertRecords()	0	4	1
A	updateRecords()	0	4	1
B	save()	0	25	6
A	create()	0	8	1
A	getFieldFromFieldName()	0	16	2
A	addUnmanagedField()	0	3	1
A	getUnamanagedFields()	0	3	1

<?php

namespace Wabel\Zoho\CRM;

use Wabel\Zoho\CRM\BeanComponents\Field;
use Wabel\Zoho\CRM\Exceptions\ExceptionZohoClient;
use Wabel\Zoho\CRM\Exceptions\ZohoCRMORMException;
use Wabel\Zoho\CRM\Helpers\BeanHelper;
use Wabel\Zoho\CRM\Helpers\ComponentHelper;
use Wabel\Zoho\CRM\Helpers\ZCRMModuleHelper;

/**
 * Base class that provides access to Zoho through Zoho beans.
 */
abstract class AbstractZohoDao
{

    /**
     * The class implementing API methods not directly related to a specific module.
     *
     * @var ZohoClient
     */
    protected $zohoClient;


    /**
     * Array that contains fields that can't be managed
     * with the ORM and are manually added with the
     * addUnmanagedField method
     * @var array
     */
    protected $unmanagedFields =  [];

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

    abstract protected function getModule();
    abstract protected function getSingularModuleName();
    abstract protected function getPluralModuleName();
    abstract protected function getBeanClassName();
    abstract protected function getFieldsDetails();

    /**
     * @return ZohoClient
     */
    public function getZohoClient(): ZohoClient
    {
        return $this->zohoClient;
    }


    /**
     * @return Field[]
     */
    public function getFields()
    {
        return array_map(
            function (array $fieldDetails) {
                return ComponentHelper::createFieldFromArray($fieldDetails);
            }, $this->getFieldsDetails()
        );
    }


    /**
     * Returns a module from Zoho.
     *
     * @return \ZCRMModule
     */
    public function getZCRMModule()
    {
        return $this->zohoClient->getModule($this->getModule());
    }

    /**
     * Parse a Zoho Response in order to retrieve one or several ZohoBeans from it.
     *
     * @param  \ZCRMRecord[] $ZCRMRecords
     * @return ZohoBeanInterface[] The array of Zoho Beans parsed from the response
     * @throws ZohoCRMORMException
     */
    protected function getBeansFromZCRMRecords(array $ZCRMRecords)
    {
        $beanClass = $this->getBeanClassName();
        $beanArray = array();

        foreach ($ZCRMRecords as $record) {

            /**
 * @var ZohoBeanInterface $bean 
*/
            $bean = new $beanClass();
            BeanHelper::updateZCRMRecordToBean($this, $bean, $record);
            $beanArray[] = $bean;
        }

        return $beanArray;
    }

    /**
     * Implements deleteRecords API method.
     *
     * @param  string $id
     * @return ZohoBeanInterface[]
     * @throws ZohoCRMORMException
     */
    public function delete($id): array
    {
        /***
         * @var $ZCRMRecordDeleted \EntityResponse[]
         */
        $ZCRMRecordsDeleted = $this->zohoClient->deleteRecords($this->getModule(), $id);

        $recordsToDeleted = array_map(
            function (\EntityResponse $ZCRMRecordDeleted) {
                return $ZCRMRecordDeleted->getData();
            }, $ZCRMRecordsDeleted
        );

        return $this->getBeansFromZCRMRecords($recordsToDeleted);
    }

    /**
     * Implements getRecordById API method.
     *
     * @param string $id Zoho Id of the record to retrieve OR an array of IDs
     *
     * @return ZohoBeanInterface The array of Zoho Beans parsed from the response
     * @throws ZohoCRMORMException
     */
    public function getById($id): ZohoBeanInterface
    {
            $module = $this->getModule();
            $ZCRMRecord = $this->zohoClient->getRecordById($module, $id);
            $beans =  $this->getBeansFromZCRMRecords([$ZCRMRecord]);

array($ZCRMRecord) is of type array<integer,object<ZCRMRecord>|null,{"0":"object<ZCRMRecord>|null"}>, but the function expects a array<integer,object<ZCRMRecord>>.

            return $beans[0];
    }

    /**
     * Implements getRecords API method.
     *
     * @param  string|null    $cvId
     * @param  string|null    $sortColumnString
     * @param  string|null    $sortOrderString
     * @param  \DateTime|null $lastModifiedTime
     * @param  int            $page
     * @param  int            $perPage
     * @return ZohoBeanInterface[]
     * @throws ZohoCRMORMException
     * @throws \ZCRMException
     */
    public function getRecords($cvId = null, $sortColumnString = null, $sortOrderString = null, \DateTime $lastModifiedTime = null, $page = 1, $perPage = 200): array
    {
        try{
            $ZCRMRecords =  ZCRMModuleHelper::getAllZCRMRecordsFromPagination($this->zohoClient, $this->getModule(),
                $cvId, $sortColumnString, $sortOrderString, $page, $perPage, $lastModifiedTime);
        } catch(\ZCRMException $exception){
            if(ExceptionZohoClient::exceptionCodeFormat($exception->getExceptionCode()) === ExceptionZohoClient::EXCEPTION_CODE_NO__CONTENT) {
                $ZCRMRecords = [];
            } else{
                $this->zohoClient->logException($exception);
                throw $exception;
            }
        }
        return $this->getBeansFromZCRMRecords($ZCRMRecords);
    }

    /**
     * Returns the list of deleted records.
     *
     * @param  \DateTimeInterface|null $lastModifiedTime
     * @param  int                     $page
     * @param  int                     $perPage
     * @return \ZCRMTrashRecord[]
     * @throws \ZCRMException
     */
    public function getDeletedRecordIds(\DateTimeInterface $lastModifiedTime = null, $page = 1, $perPage = 200)
    {
        return ZCRMModuleHelper::getAllZCRMTrashRecordsFromPagination($this->zohoClient, $this->getModule(), 'all', $lastModifiedTime, $page, $perPage);
    }

    /**
     * @Todo
     */
    // public function getRelatedRecords
    // public function searchRecords
    // public function uploadFile
    // public function downloadFile

    /**
     * Implements insertRecords or updateRecords or upsertRecords API method.
     *
     * @param  ZohoBeanInterface[] $beans
     * @param  bool                $wfTrigger Whether or not the call should trigger the workflows related to a "created" event
     * @throws ZohoCRMORMException
     */
    public function createOrUpdate( array $beans, bool $wfTrigger = false, $action = 'upsert'): void
    {
        /**
         * @var $records \ZCRMRecord[]
         */
        $records = [];

        $dao = $this;
        $processAction = ($action === 'update')?'updating':$action.'ing';

        foreach (array_chunk($beans, 100) as $beansPool) {
            /**
             * @var $beansPool ZohoBeanInterface[]
             */
            $recordsToMerge = array_map(
                function ($beanPool) use ($dao) {
                    /**
                     * @var $beanPool ZohoBeanInterface
                     */
                    BeanHelper::createOrUpdateBeanToZCRMRecord($dao, $beanPool);
                    return $beanPool->getZCRMRecord();
                }, $beansPool
            );
            $records = array_merge($records, $recordsToMerge);
            switch ($action){
            case 'insert':
                 $this->zohoClient->insertRecords($this->getModule(), $records, $wfTrigger);
                break;
            case 'update':
                $this->zohoClient->updateRecords($this->getModule(), $records, $wfTrigger);
                break;
            case 'upsert':
            default:
                $this->zohoClient->upsertRecords($this->getModule(), $records);
            }
        }
        if (count($records) != count($beans)) {
            throw new ZohoCRMORMException('Error while '.$processAction.' beans in Zoho. '.count($beans).' passed in parameter, but '.count($records).' returned.');
        }

        foreach ($beans as $key => $bean) {
            BeanHelper::updateZCRMRecordToBean($dao, $bean, $records[$key]);
        }
    }

    /**
     * Implements insertRecords API method.
     *
     * @param  ZohoBeanInterface[] $beans
     * @param  bool                $wfTrigger Whether or not the call should trigger the workflows related to a "created" event
     * @throws ZohoCRMORMException
     */
    public function insertRecords( array $beans, bool $wfTrigger = false): void
    {
        $this->createOrUpdate($beans, $wfTrigger, 'insert');
    }

    /**
     * Implements updateRecords API method.
     *
     * @param  ZohoBeanInterface[] $beans
     * @param  bool                $wfTrigger
     * @throws ZohoCRMORMException
     */
    public function updateRecords(array $beans, bool $wfTrigger = false): void
    {
        $this->createOrUpdate($beans, $wfTrigger, 'update');
    }

    /**
     * Saves the bean or array of beans passed in Zoho.
     * It will perform an insert if the bean has no ZohoID or an update if the bean has a ZohoID.
     * wfTrigger only usable for a single record update/insert.
     *
     * @param ZohoBeanInterface|ZohoBeanInterface[] $beans     A bean or an array of beans.
     * @param bool                                  $wfTrigger
     */
    public function save($beans, $wfTrigger = false): void
    {

        if (!is_array($beans)) {
            $beans = [$beans];
        }

        $toInsert = [];
        $toUpdate = [];

        foreach ($beans as $bean) {
            if ($bean->getZohoId()) {
                $toUpdate[] = $bean;
            } else {
                $toInsert[] = $bean;
            }
        }

        if ($toInsert) {

The expression $toInsert of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->insertRecords($toInsert, $wfTrigger);
        }
        if ($toUpdate) {

The expression $toUpdate of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->updateRecords($toUpdate, $wfTrigger);
        }
    }

    /**
     * @return ZohoBeanInterface
     * @throws ZohoCRMORMException
     */
    public function create()
    {
        $record = \ZCRMRecord::getInstance($this->getModule(), null);
        $beanClassName = $this->getBeanClassName();
        $bean = new $beanClassName();
        BeanHelper::updateZCRMRecordToBean($this, $bean, $record);
        return $bean;
    }

    /**
     * @param  $fieldName
     * @return null|Field
     */
    public function getFieldFromFieldName($fieldName)
    {
        $fields = $this->getFields();
        /**
         * @var Field[] $field
         */
        $field = array_values(
            array_filter(
                $fields, function (Field $fiedObj) use ($fieldName) {
                    return $fiedObj->getName() === $fieldName;
                }
            )
        );

        return count($field) === 1?$field[0] :null;
    }


    /**
     * Add a field that can't be managed with the ORM
     *
     * @param $fieldApiName
     * @param $value
     */
    public function addUnmanagedField($fieldApiName, $value) {
        $this->unmanagedFields[$fieldApiName] = $value;
    }

    /**
     * @return array
     */
    public function getUnamanagedFields() {
        return $this->unmanagedFields;
    }
}