Issues in DetectAppointmentsChangingsService.php (master) - Issues in master - Wabel/certain-api-wrapper - Measure and Improve Code Quality continuously with Scrutinizer

Issues (29)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

Services/DetectAppointmentsChangingsService.php (4 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Wabel\CertainAPI\Services;

use Logger\Formatters\DateTimeFormatter;
use Mouf\Utils\Common\Lock;
use Mouf\Utils\Log\Psr\MultiLogger;
use Symfony\Component\Console\Logger\ConsoleLogger;
use Symfony\Component\Console\Output\OutputInterface;
use Wabel\CertainAPI\Helpers\FileChangesHelper;
use Wabel\CertainAPI\Interfaces\CertainListener;
use Wabel\CertainAPI\Ressources\AppointmentsCertain;

class DetectAppointmentsChangingsService
{

    /**
     * @var AppointmentsCertain
     */
    private $appointmentsCertain;
    /**
     * @var MultiLogger
     */
    private $logger;
    /**
     * @var Lock
     */
    private $lock;
    /**
     * @var string
     */
    private $dirPathHistoryAppointments;
    /**
     * @var CertainListener[]
     */
    private $listeners;

    /**
     * @param CertainListener[] $listeners
     */
    public function __construct(AppointmentsCertain $appointmentsCertain, MultiLogger $logger, Lock $lock, string $dirPathHistoryAppointments, array $listeners = [])
    {
        $this->appointmentsCertain = $appointmentsCertain;
        $this->logger = $logger;
        $this->lock = $lock;
        $this->dirPathHistoryAppointments = $dirPathHistoryAppointments;
        $this->listeners = $listeners;
    }

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

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $start = 0;
        }
        if (!$maxResult) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $maxResult = 999999;
        }
        return $this->certainAppointmentsList = $this->appointmentsCertain->get($eventCode, ['start_index' => $start, 'max_results' => $maxResult])->getResults()->appointments;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * @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
     * @return array
     */
    private function arrayRecursiveDiffNew(array $arrayOlds, array $arrayNews)
    {
        $difference = [];
        $appointmentIdOlds = array_map(function($appointment) {
            return $appointment['appointmentId'];
        }, $arrayOlds);
        foreach ($arrayNews as $key => $arrayNew) {
            if (!in_array($arrayNew['appointmentId'], $appointmentIdOlds)) {
                $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));
        }
        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'];
            $runInNew = 0;
            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[] = $currentAppointment;
                    break;
                }
                $runInNew++;
            }
            if ($runInNew === count($appointmentsNew) && !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;
    }

    public function runCommandForEvent(string $eventCode, OutputInterface $output = null): void
    {
        if ($output) {
            $this->logger->addLogger(new DateTimeFormatter(new ConsoleLogger($output)));
        }
        $codeCheckDirectory = FileChangesHelper::checkDirectory($this->dirPathHistoryAppointments);
        if ($codeCheckDirectory === 'no_directory') {
            $this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' doesn\'t exists.');
            return;
        }
        if ($codeCheckDirectory === 'not_readable') {
            $this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' is not readable.');
            return;
        }
        if ($codeCheckDirectory === 'not_writable') {
            $this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' is not writable.');
            return;
        }
        $this->lock->acquireLock();
        $this->logger->info('Detect changes - Run.');
        //That permits to stop the followings instructions when we are makings changes on Certain.
        //Get the online appointments.
        $appointmentsNewCertain = $this->getCurrentAppoiments($eventCode);
        $appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNewCertain);
        //Get the last saved appointments to get old data.
        $appointmentsOldHistoryFilePath = FileChangesHelper::getTheLastAppointmentsSaved($eventCode, $this->dirPathHistoryAppointments);
        if (!$appointmentsOldHistoryFilePath) {
            //No files so it's the first time we attempt to synchronize.
            $appointmentsOld = [];
        } else {
            //Get the last old appointments data.
            $appointmentsOldHistory = FileChangesHelper::getJsonContentFromFile($appointmentsOldHistoryFilePath);
            $appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOldHistory);
        }
        //Check if they are changes.
        $timestamp = time();
//        $listChangings = $this->detectAppointmentsChangings($appointmentsOld, $appointmentsNew, $timestamp);
        $listChangings = $this->detectAppointmentsChanges($appointmentsOld, $appointmentsNew, $timestamp);
        if (!$appointmentsOld || ((isset($listChangings['updated']) && !empty($listChangings['updated']))

                || (isset($listChangings['deleted']) && !empty($listChangings['deleted']))  || (isset($listChangings['inserted']) && !empty($listChangings['inserted'])))) {
            //Changes? So we save the new online appointments
            FileChangesHelper::saveAppointmentsFileByHistory($this->dirPathHistoryAppointments . '/appointments_' . $eventCode . '.json', json_encode($appointmentsNew));
            $this->logger->info('Detect changes - Save Changes');
        } else {
            $this->logger->info('Detect changes - No Changes');
        }
        FileChangesHelper::saveAppointmentsFileByHistory($this->dirPathHistoryAppointments . '/changes_' . $eventCode . '.json', json_encode($listChangings));
        foreach ($this->listeners as $listener) {
            //Run Listener. For instance,Here we can use ChangingsToFileListeners to save the changes in file.
            $listener->run($eventCode, $listChangings);
        }
        $this->logger->info('Detect changes - Stop.');
        $this->lock->releaseLock();
    }

    private function detectAppointmentsChanges(array $appointmentsOld, array $appointmentsNew, int $timestamp)
    {
        $oldAppointments = [];
        $newAppointments = [];
        $oldAppointmentIds = [];
        $newAppointmentIds = [];

        foreach ($appointmentsOld as $item) {
            $oldAppointments[$item['appointmentId']] = $item;
            $oldAppointmentIds[] = $item['appointmentId'];
        }
        foreach ($appointmentsNew as $item) {
            $newAppointments[$item['appointmentId']] = $item;
            $newAppointmentIds[] = $item['appointmentId'];
        }

        $data = [
            'inserted' => [],
            'updated' => [],
            'deleted' => [],
        ];

        $data['inserted'] = array_map(static function($item) use ($newAppointments) {
            return $newAppointments[$item];
        }, array_diff($newAppointmentIds, $oldAppointmentIds));

        $data['deleted'] = array_map(static function($item) use ($oldAppointments) {
            return $oldAppointments[$item];
        }, array_diff($oldAppointmentIds, $newAppointmentIds));

        $updatedIds = array_keys(array_intersect_key($newAppointments, $oldAppointments));
        foreach ($updatedIds as $updatedId) {
            // Important we use simple != and not strict !== to avoid issue if positions in array are different
            if ($newAppointments[$updatedId] != $oldAppointments[$updatedId]) {
                $data['updated'][] = $newAppointments[$updatedId];
            }
        }

        $data['inserted'] = self::insertDateTimeChanges($data['inserted'], $timestamp);
        $data['updated'] = self::insertDateTimeChanges($data['updated'], $timestamp);
        $data['deleted'] = self::insertDateTimeChanges($data['deleted'], $timestamp);

        return $data;
    }

}


1			<?php
2
3			namespace Wabel\CertainAPI\Services;
4
5			use Logger\Formatters\DateTimeFormatter;
6			use Mouf\Utils\Common\Lock;
7			use Mouf\Utils\Log\Psr\MultiLogger;
8			use Symfony\Component\Console\Logger\ConsoleLogger;
9			use Symfony\Component\Console\Output\OutputInterface;
10			use Wabel\CertainAPI\Helpers\FileChangesHelper;
11			use Wabel\CertainAPI\Interfaces\CertainListener;
12			use Wabel\CertainAPI\Ressources\AppointmentsCertain;
13
14			class DetectAppointmentsChangingsService
15			{
16
17			/**
18			* @var AppointmentsCertain
19			*/
20			private $appointmentsCertain;
21			/**
22			* @var MultiLogger
23			*/
24			private $logger;
25			/**
26			* @var Lock
27			*/
28			private $lock;
29			/**
30			* @var string
31			*/
32			private $dirPathHistoryAppointments;
33			/**
34			* @var CertainListener[]
35			*/
36			private $listeners;
37
38			/**
39			* @param CertainListener[] $listeners
40			*/
41			public function __construct(AppointmentsCertain $appointmentsCertain, MultiLogger $logger, Lock $lock, string $dirPathHistoryAppointments, array $listeners = [])
42			{
43			$this->appointmentsCertain = $appointmentsCertain;
44			$this->logger = $logger;
45			$this->lock = $lock;
46			$this->dirPathHistoryAppointments = $dirPathHistoryAppointments;
47			$this->listeners = $listeners;
48			}
49
50			/**
51			* @param $eventCode
52			* @param null\|int $start
53			* @param null\|int $maxResult
54			* @return mixed
55			*/
56			public function getCurrentAppoiments($eventCode, $start = null, $maxResult = null)
57			{
58			if (!$start) {
			0 ignored issues – show Bug Best Practice introduced 2017-09-07 12:49 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
59			$start = 0;
60			}
61			if (!$maxResult) {
			0 ignored issues – show Bug Best Practice introduced 2017-09-08 17:01 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
62			$maxResult = 999999;
63			}
64			return $this->certainAppointmentsList = $this->appointmentsCertain->get($eventCode, ['start_index' => $start, 'max_results' => $maxResult])->getResults()->appointments;
			0 ignored issues – show Bug introduced 2017-09-07 12:49 UTC by Report Bug Copy Issue Report Show Similar Issues like this The property `certainAppointmentsList` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
65			}
66
67			/**
68			* @param array $appointmentsOld
69			* @param array $appointmentsNew
70			* @return bool
71			*/
72			public function hasChanged(array $appointmentsOld, array $appointmentsNew)
73			{
74			$hasChanged = false;
75			$appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOld);
76			$appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNew);
77			//Has change by update or delete
78			foreach ($appointmentsOld as $appointmentOld) {
79			if (!in_array($appointmentOld, $appointmentsNew)) {
80			$hasChanged = true;
81			break;
82			}
83			}
84			//Has changes by insertion or update
85			if (!$hasChanged) {
86			foreach ($appointmentsNew as $appointmentNew) {
87			if (!in_array($appointmentNew, $appointmentsOld)) {
88			$hasChanged = true;
89			break;
90			}
91			}
92			}
93			return $hasChanged;
94			}
95
96			/**
97			* @param $object
98			* @return array
99			*/
100			public static function objectToArray($object)
101			{
102			if (is_object($object)) {
103
104			return (array)$object;
105			}
106			return $object;
107			}
108
109			/**
110			* @param $appointments
111			* @return array
112			*/
113			public static function recursiveArrayObjectToFullArray($appointments)
114			{
115			return json_decode(json_encode($appointments), true);
116			}
117
118			/**
119			* @param array $arrayOlds
120			* @param array $arrayNews
121			* @return array
122			*/
123			private function arrayRecursiveDiff(array $arrayOlds, array $arrayNews)
124			{
125			$difference = [];
126			foreach ($arrayOlds as $key => $arrayOld) {
127			if (!in_array($arrayOld, $arrayNews)) {
128			$difference[$key] = $arrayOld;
129			}
130			}
131			return $difference;
132			}
133
134			/**
135			* @param array $arrayOlds
136			* @param array $arrayNews
137			* @return array
138			*/
139			private function arrayRecursiveDiffNew(array $arrayOlds, array $arrayNews)
140			{
141			$difference = [];
142			$appointmentIdOlds = array_map(function($appointment) {
143			return $appointment['appointmentId'];
144			}, $arrayOlds);
145			foreach ($arrayNews as $key => $arrayNew) {
146			if (!in_array($arrayNew['appointmentId'], $appointmentIdOlds)) {
147			$difference[$key] = $arrayNew;
148			}
149			}
150			return $difference;
151			}
152
153			/**
154			* @param array $appointmentsOld
155			* @param array $appointmentsNew
156			* @return array
157			*/
158			public function getListChangings(array $appointmentsOld, array $appointmentsNew)
159			{
160			$appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOld);
161			$appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNew);
162			$changesListUpdateOrDelete = [];
163			$changesListInsert = [];
164			if ($this->hasChanged($appointmentsOld, $appointmentsNew)) {
165			$changesListUpdateOrDelete = self::recursiveArrayObjectToFullArray($this->arrayRecursiveDiff($appointmentsOld, $appointmentsNew));
166			$changesListInsert = self::recursiveArrayObjectToFullArray($this->arrayRecursiveDiffNew($appointmentsOld, $appointmentsNew));
167			}
168			return [
169			'inserted' => $changesListInsert,
170			'updated_deleted' => $changesListUpdateOrDelete
171			];
172			}
173
174			/**
175			*
176			* @param array $currentAppointments
177			* @param array $changingsDetected
178			* @return array ['deleted'=>[],'updated'=>[]]
179			*/
180			public function detectDeleteOrUpdated(array $currentAppointments, array $changingsDetected)
181			{
182			$delete = [];
183			$update = [];
184			//@Todo: Detect Fields has changed
185			$appointmentsNew = self::recursiveArrayObjectToFullArray($currentAppointments);
186			$changings = self::recursiveArrayObjectToFullArray($changingsDetected);
187			foreach ($changings as $changing) {
188			$registration = $changing['registration']['regCode'];
189			$registrationTarget = $changing['targetRegistration']['regCode'];
190			$runInNew = 0;
191			foreach ($appointmentsNew as $currentAppointment) {
192			$registrationCurrent = $currentAppointment['registration']['regCode'];
193			$registrationTargetCurrent = $currentAppointment['targetRegistration']['regCode'];
194			if (in_array($registration, [$registrationCurrent, $registrationTargetCurrent])
195			&& in_array($registrationTarget, [$registrationCurrent, $registrationTargetCurrent])
196			&& !in_array($changing, $update) && !in_array($changing, $delete)) {
197			$update[] = $currentAppointment;
198			break;
199			}
200			$runInNew++;
201			}
202			if ($runInNew === count($appointmentsNew) && !in_array($changing, $delete)) {
203			$delete[] = $changing;
204			}
205
206			}
207			return [
208			'deleted' => $delete,
209			'updated' => $update,
210			];
211			}
212
213			/**
214			* @param array $appointments
215			* @param $timestamp
216			* @return array
217			*/
218			public static function insertDateTimeChanges(array $appointments, $timestamp)
219			{
220			foreach ($appointments as $key => $appointment) {
221			$appointments[$key]['dateDetectChanges'] = $timestamp;
222			}
223			return $appointments;
224			}
225
226			/**
227			* @param array $appointmentsOld
228			* @param array $appointmentsNew
229			* @param string $timestamp
230			* @return array ['deleted'=>[],'updated'=>[]]
231			*/
232			public function detectAppointmentsChangings(array $appointmentsOld, array $appointmentsNew, $timestamp)
233			{
234			$changings = $this->getListChangings($appointmentsOld, $appointmentsNew);
235			$changesList = $this->detectDeleteOrUpdated($appointmentsNew, $changings['updated_deleted']);
236			$changesList['inserted'] = self::insertDateTimeChanges($changings['inserted'], $timestamp);
237			$changesList['updated'] = self::insertDateTimeChanges($changesList['updated'], $timestamp);
238			$changesList['deleted'] = self::insertDateTimeChanges($changesList['deleted'], $timestamp);
239			return $changesList;
240			}
241
242			public function runCommandForEvent(string $eventCode, OutputInterface $output = null): void
243			{
244			if ($output) {
245			$this->logger->addLogger(new DateTimeFormatter(new ConsoleLogger($output)));
246			}
247			$codeCheckDirectory = FileChangesHelper::checkDirectory($this->dirPathHistoryAppointments);
248			if ($codeCheckDirectory === 'no_directory') {
249			$this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' doesn\'t exists.');
250			return;
251			}
252			if ($codeCheckDirectory === 'not_readable') {
253			$this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' is not readable.');
254			return;
255			}
256			if ($codeCheckDirectory === 'not_writable') {
257			$this->logger->error('Path ' . $this->dirPathHistoryAppointments . ' is not writable.');
258			return;
259			}
260			$this->lock->acquireLock();
261			$this->logger->info('Detect changes - Run.');
262			//That permits to stop the followings instructions when we are makings changes on Certain.
263			//Get the online appointments.
264			$appointmentsNewCertain = $this->getCurrentAppoiments($eventCode);
265			$appointmentsNew = self::recursiveArrayObjectToFullArray($appointmentsNewCertain);
266			//Get the last saved appointments to get old data.
267			$appointmentsOldHistoryFilePath = FileChangesHelper::getTheLastAppointmentsSaved($eventCode, $this->dirPathHistoryAppointments);
268			if (!$appointmentsOldHistoryFilePath) {
269			//No files so it's the first time we attempt to synchronize.
270			$appointmentsOld = [];
271			} else {
272			//Get the last old appointments data.
273			$appointmentsOldHistory = FileChangesHelper::getJsonContentFromFile($appointmentsOldHistoryFilePath);
274			$appointmentsOld = self::recursiveArrayObjectToFullArray($appointmentsOldHistory);
275			}
276			//Check if they are changes.
277			$timestamp = time();
278			// $listChangings = $this->detectAppointmentsChangings($appointmentsOld, $appointmentsNew, $timestamp);
279			$listChangings = $this->detectAppointmentsChanges($appointmentsOld, $appointmentsNew, $timestamp);
280			if (!$appointmentsOld \|\| ((isset($listChangings['updated']) && !empty($listChangings['updated']))
			0 ignored issues – show Bug Best Practice introduced 2017-09-07 12:49 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$appointmentsOld` 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 check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
281			\|\| (isset($listChangings['deleted']) && !empty($listChangings['deleted'])) \|\| (isset($listChangings['inserted']) && !empty($listChangings['inserted'])))) {
282			//Changes? So we save the new online appointments
283			FileChangesHelper::saveAppointmentsFileByHistory($this->dirPathHistoryAppointments . '/appointments_' . $eventCode . '.json', json_encode($appointmentsNew));
284			$this->logger->info('Detect changes - Save Changes');
285			} else {
286			$this->logger->info('Detect changes - No Changes');
287			}
288			FileChangesHelper::saveAppointmentsFileByHistory($this->dirPathHistoryAppointments . '/changes_' . $eventCode . '.json', json_encode($listChangings));
289			foreach ($this->listeners as $listener) {
290			//Run Listener. For instance,Here we can use ChangingsToFileListeners to save the changes in file.
291			$listener->run($eventCode, $listChangings);
292			}
293			$this->logger->info('Detect changes - Stop.');
294			$this->lock->releaseLock();
295			}
296
297			private function detectAppointmentsChanges(array $appointmentsOld, array $appointmentsNew, int $timestamp)
298			{
299			$oldAppointments = [];
300			$newAppointments = [];
301			$oldAppointmentIds = [];
302			$newAppointmentIds = [];
303
304			foreach ($appointmentsOld as $item) {
305			$oldAppointments[$item['appointmentId']] = $item;
306			$oldAppointmentIds[] = $item['appointmentId'];
307			}
308			foreach ($appointmentsNew as $item) {
309			$newAppointments[$item['appointmentId']] = $item;
310			$newAppointmentIds[] = $item['appointmentId'];
311			}
312
313			$data = [
314			'inserted' => [],
315			'updated' => [],
316			'deleted' => [],
317			];
318
319			$data['inserted'] = array_map(static function($item) use ($newAppointments) {
320			return $newAppointments[$item];
321			}, array_diff($newAppointmentIds, $oldAppointmentIds));
322
323			$data['deleted'] = array_map(static function($item) use ($oldAppointments) {
324			return $oldAppointments[$item];
325			}, array_diff($oldAppointmentIds, $newAppointmentIds));
326
327			$updatedIds = array_keys(array_intersect_key($newAppointments, $oldAppointments));
328			foreach ($updatedIds as $updatedId) {
329			// Important we use simple != and not strict !== to avoid issue if positions in array are different
330			if ($newAppointments[$updatedId] != $oldAppointments[$updatedId]) {
331			$data['updated'][] = $newAppointments[$updatedId];
332			}
333			}
334
335			$data['inserted'] = self::insertDateTimeChanges($data['inserted'], $timestamp);
336			$data['updated'] = self::insertDateTimeChanges($data['updated'], $timestamp);
337			$data['deleted'] = self::insertDateTimeChanges($data['deleted'], $timestamp);
338
339			return $data;
340			}
341
342			}
343

Wabel / certain-api-wrapper

Issues (29)

Security Analysis no request data

Services/DetectAppointmentsChangingsService.php (4 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like