Wabel\CertainAPI\Services\DetectAppointmentsChangingsService

Complexity

Total Complexity

34

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getCurrentAppoiments()	0	9	3
B	hasChanged()	0	22	6
A	objectToArray()	0	7	2
A	recursiveArrayObjectToFullArray()	0	3	1
A	arrayRecursiveDiff()	0	9	3
A	arrayRecursiveDiffNew()	0	10	4
A	getListChangings()	0	14	2
D	detectDeleteOrUpdated()	0	29	9
A	insertDateTimeChanges()	0	6	2
A	detectAppointmentsChangings()	0	8	1

<?php

namespace Wabel\CertainAPI\Services;

use Wabel\CertainAPI\Ressources\AppointmentsCertain;

class DetectAppointmentsChangingsService
{

    /**
     * @var AppointmentsCertain
     */
    private $appointmentsCertain;

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

    /**
     * @param $eventCode
     * @param null|int $start
     * @param null|int $maxResult
     * @return mixed
     */
    public function getCurrentAppoiments($eventCode,$start=null,$maxResult=null){
        if(!$start){

The expression $start of type null|integer is loosely compared to false; this is ambiguous if the integer can be zero. You might want to explicitly use === null instead.

            $start = 0;
        }
        if(!$maxResult){

The expression $maxResult of type null|integer is loosely compared to false; this is ambiguous if the integer can be zero. You might want to explicitly use === null instead.

            $maxResult = 999999;
        }
        return $this->certainAppointmentsList = $this->appointmentsCertain->get($eventCode,['start_index'=>$start,'max_results'=>$maxResult])->getResults()->appointments;

The property certainAppointmentsList does not exist. Did you maybe forget to declare it?

    }

    /**
     * @param array $appointmentsOld
     * @param array $appointmentsNew
     * @return bool
     */
    public function hasChanged(array $appointmentsOld,array $appointmentsNew){
        $hasChanged = false;
        $appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOld);
        $appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNew);
        //Has change by update or delete
        foreach ($appointmentsOld as $appointmentOld){
            if(!in_array($appointmentOld,$appointmentsNew)){
                $hasChanged = true;
                break;
            }
        }
        //Has changes by insertion or update
        if(!$hasChanged){
            foreach ($appointmentsNew as $appointmentNew){
                if(!in_array($appointmentNew,$appointmentsOld)){
                    $hasChanged = true;
                    break;
                }
            }
        }
        return $hasChanged;
    }

    /**
     * @param $object
     * @return array
     */
    public static  function objectToArray($object) {
        if(is_object($object)){

            return (array) $object;
        }
        return $object;
    }

    /**
     * @param $appointments
     * @return array
     */
    public static function recursiveArrayObjectToFullArray($appointments){
        return json_decode(json_encode($appointments), true);
    }

    /**
     * @param array $arrayOlds
     * @param array $arrayNews
     * @return array
     */
    private function arrayRecursiveDiff(array $arrayOlds, array $arrayNews) {
        $difference = [];
        foreach($arrayOlds as $key => $arrayOld){
            if(!in_array($arrayOld,$arrayNews)){
                $difference[$key] = $arrayOld;
            }
        }
        return $difference;
    }

    /**
     * @param array $arrayOlds
     * @param array $arrayNews
     * @param array $existedUpdateOrDelete
     * @return array
     */
    private function arrayRecursiveDiffNew(array $arrayOlds, array $arrayNews, array $existedUpdateOrDelete) {
        $difference = [];
        foreach($arrayNews as $key => $arrayNew){
            if(!in_array($arrayNew,$arrayOlds)
                && !in_array(self::recursiveArrayObjectToFullArray($arrayNew), $existedUpdateOrDelete)){
                $difference[$key] = $arrayNew;
            }
        }
        return $difference;
    }

    /**
     * @param array $appointmentsOld
     * @param array $appointmentsNew
     * @return array
     */
    public function getListChangings(array $appointmentsOld,array $appointmentsNew){
        $appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOld);
        $appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNew);
        $changesListUpdateOrDelete = [];
        $changesListInsert = [];
        if($this->hasChanged($appointmentsOld,$appointmentsNew)){
            $changesListUpdateOrDelete = self::recursiveArrayObjectToFullArray($this->arrayRecursiveDiff($appointmentsOld,$appointmentsNew));
            $changesListInsert = self::recursiveArrayObjectToFullArray($this->arrayRecursiveDiffNew($appointmentsOld, $appointmentsNew, $changesListUpdateOrDelete));
        }
        return [
            'inserted' => $changesListInsert,
            'updated_deleted' => $changesListUpdateOrDelete
        ];
    }

    /**
     *
     * @param array $currentAppointments
     * @param array $changingsDetected
     * @return array ['deleted'=>[],'updated'=>[]]
     */
    public function detectDeleteOrUpdated(array $currentAppointments, array $changingsDetected){
        $delete = [];
        $update = [];
        //@Todo: Detect Fields has changed
        $appointmentsNew = self::recursiveArrayObjectToFullArray($currentAppointments);
        $changings = self::recursiveArrayObjectToFullArray($changingsDetected);
        foreach ($changings as $changing){
            $registration = $changing['registration']['regCode'];
            $registrationTarget = $changing['targetRegistration']['regCode'];
            foreach ($appointmentsNew as $currentAppointment){
                $registrationCurrent = $currentAppointment['registration']['regCode'];
                $registrationTargetCurrent = $currentAppointment['targetRegistration']['regCode'];
                if(in_array($registration,[$registrationCurrent,$registrationTargetCurrent])
                    && in_array($registrationTarget,[$registrationCurrent,$registrationTargetCurrent])
                     && !in_array($changing,$update) && !in_array($changing,$delete)) {
                    $update[] = $changing;
                    break;
                }
            }
            if(!in_array($changing, $update) && !in_array($changing,$delete)){
                $delete[] = $changing;
            }

        }
        return [
            'deleted' => $delete,
            'updated' => $update,
        ];
    }

    /**
     * @param array $appointments
     * @param $timestamp
     * @return array
     */
    public static function insertDateTimeChanges(array $appointments,$timestamp){
        foreach ($appointments as $key => $appointment){
            $appointments[$key]['dateDetectChanges'] = $timestamp;
        }
        return $appointments;
    }

    /**
     * @param array $appointmentsOld
     * @param array $appointmentsNew
     * @param string $timestamp
     * @return array ['deleted'=>[],'updated'=>[]]
     */
    public function detectAppointmentsChangings(array $appointmentsOld,array $appointmentsNew,$timestamp){
        $changings = $this->getListChangings($appointmentsOld,$appointmentsNew);
        $changesList = $this->detectDeleteOrUpdated($appointmentsNew,$changings['updated_deleted']);
        $changesList['inserted'] = self::insertDateTimeChanges($changings['inserted'],$timestamp);
        $changesList['updated'] = self::insertDateTimeChanges($changesList['updated'],$timestamp);
        $changesList['deleted'] = self::insertDateTimeChanges($changesList['deleted'],$timestamp);
        return $changesList;
    }

}