AlfredTime\Timer

Complexity

Total Complexity

50

Size/Duplication

Total Lines	345
Duplicated Lines	6.96 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	delete()	0	17	4
A	deleteServiceTimer()	0	12	3
A	getDescription()	0	4	1
A	getPrimaryService()	0	4	1
A	getProjectName()	0	15	3
A	getProjects()	0	4	1
A	getRecentTimers()	12	12	3
A	getServiceDataCache()	0	10	2
A	getTags()	0	4	1
A	isRunning()	0	4	1
A	setNotificationForService()	0	8	2
C	start()	0	36	7
A	stop()	0	19	4
A	syncOnlineDataToLocalCache()	12	12	3
A	undo()	0	10	2
A	updateProperty()	0	4	1
B	getItems()	0	19	5
A	getProperty()	0	4	1
A	getRecentServiceTimers()	0	4	1
A	saveServiceDataCache()	0	5	1
A	syncServiceOnlineDataToLocalCache()	0	12	2

<?php

namespace AlfredTime;

use AlfredTime\Toggl;
use AlfredTime\Config;
use AlfredTime\Harvest;

class Timer
{
    /**
     * @var mixed
     */
    private $config;

    /**
     * @var mixed
     */
    private $harvest;

    /**
     * @var mixed
     */
    private $toggl;

    /**
     * @param Config $config
     */
    public function __construct(Config $config = null)
    {
        $this->config = $config;
        $this->harvest = new Harvest($this->config->get('harvest', 'domain'), $this->config->get('harvest', 'api_token'));
        $this->toggl = new Toggl($this->config->get('toggl', 'api_token'));
    }

    /**
     * @param  $timerId
     * @return string
     */
    public function delete(array $timerData = [])
    {
        $message = '';
        $oneTimerDeleted = false;

        foreach ($timerData as $service => $id) {
            $res = $this->deleteServiceTimer($service, $id);
            $message .= $this->setNotificationForService($service, 'delete', $res);
            $oneTimerDeleted = $oneTimerDeleted || $res;
        }

        if ($oneTimerDeleted === true) {
            $this->updateProperty('is_running', false);
        }

        return $message;
    }

    /**
     * @param  $service
     * @param  $timerId
     * @return boolean
     */
    public function deleteServiceTimer($service, $timerId)
    {
        if ($this->$service->deleteTimer($timerId) === false) {
            return false;
        }

        if ($timerId === $this->getProperty($service . '_id')) {
            $this->updateProperty($service . '_id', null);
        }

        return true;
    }

    /**
     * @return mixed
     */
    public function getDescription()
    {
        return $this->getProperty('description');
    }

    /**
     * @return mixed
     */
    public function getPrimaryService()
    {
        return $this->getProperty('primary_service');
    }

    /**
     * @param  $projectId
     * @return mixed
     */
    public function getProjectName($projectId)
    {
        $projectName = '';

        $projects = $this->getProjects();

        foreach ($projects as $project) {
            if ($project['id'] === $projectId) {
                $projectName = $project['name'];
                break;
            }
        }

        return $projectName;
    }

    /**
     * @return mixed
     */
    public function getProjects()
    {
        return $this->getItems('projects');
    }

    /**
     * @return mixed
     */
    public function getRecentTimers()

This method seems to be duplicated in your project.

    {
        $timers = [];

        foreach ($this->config->implementedServicesForFeature('get_timers') as $service) {
            if ($this->config->isServiceActive($service) === true) {
                $timers = array_merge($timers, $this->getRecentServiceTimers($service));
            }
        }

        return $timers;
    }

    /**
     * @param  $service
     * @return mixed
     */
    public function getServiceDataCache($service)
    {
        $cacheFile = getenv('alfred_workflow_data') . '/' . $service . '_cache.json';

        if (file_exists($cacheFile) === false) {
            $this->syncServiceOnlineDataToLocalCache($service);
        }

        return json_decode(file_get_contents($cacheFile), true);
    }

    /**
     * @return mixed
     */
    public function getTags()
    {
        return $this->getItems('tags');
    }

    /**
     * @return mixed
     */
    public function isRunning()
    {
        return $this->getProperty('is_running');
    }

    /**
     * @param $service
     * @param null       $action
     * @param null       $success
     */
    public function setNotificationForService($service = null, $action = null, $success = null)
    {
        if (empty($success) === true) {
            return '- ' . ucfirst($service) . ': cannot ' . $action . ' [' . $this->$service->getLastMessage() . ']' . "\r\n";
        }

        return '- ' . ucfirst($service) . ': ' . $action . "\r\n";
    }

    /**
     * @param  $description
     * @param  $projectsData
     * @param  $tagData
     * @return string
     */
    public function start($description = '', array $projectData = [], array $tagData = [], $specificService = null)
    {
        $message = '';
        $oneServiceStarted = false;

        $servicesToRun = ($specificService === null) ? $this->config->implementedServicesForFeature('start') : [$specificService];

        /**
         * When starting a new timer, all the services timer IDs have to be put to null
         * so that when the user uses the UNDO feature, it doesn't delete old previous
         * other services timers. The timer IDs are used for the UNDO feature and
         * should then contain the IDs of the last starts through the workflow, not
         * through each individual sefrvice
         */
        if (empty($servicesToRun) === true) {
            return '';
        }

        foreach ($this->config->activatedServices() as $service) {
            $this->updateProperty($service . '_id', null);
        }

        foreach ($servicesToRun as $service) {
            $timerId = $this->$service->startTimer($description, $projectData[$service . '_id'], $tagData[$service . '_id']);
            $this->updateProperty($service . '_id', $timerId);
            $message .= $this->setNotificationForService($service, 'start', $timerId);
            $oneServiceStarted = $oneServiceStarted || ($timerId !== null);
        }

        if ($oneServiceStarted === true) {
            $this->updateProperty('description', $description);
            $this->updateProperty('is_running', true);
        }

        return $message;
    }

    /**
     * @return string
     */
    public function stop()
    {
        $message = '';
        $oneServiceStopped = false;

        foreach ($this->config->runningServices() as $service) {
            $timerId = $this->getProperty($service . '_id');

            $res = $this->$service->stopTimer($timerId);
            $message .= $this->setNotificationForService($service, 'stop', $res);
            $oneServiceStopped = $oneServiceStopped || $res;
        }

        if ($oneServiceStopped === true) {
            $this->updateProperty('is_running', false);
        }

        return $message;
    }

    /**
     * @return string
     */
    public function syncOnlineDataToLocalCache()

This method seems to be duplicated in your project.

    {
        $message = '';

        foreach ($this->config->implementedServicesForFeature('sync_data') as $service) {
            if ($this->config->isServiceActive($service) === true) {
                $message .= $this->syncServiceOnlineDataToLocalCache($service);
            }
        }

        return $message;
    }

    /**
     * @return string
     */
    public function undo()
    {
        $timerData = [];

        foreach ($this->config->runningServices() as $service) {
            $timerData[$service] = $this->getProperty($service . '_id');
        }

        return $this->delete($timerData);
    }

    /**
     * @param $name
     * @param $value
     */
    public function updateProperty($name, $value)
    {
        $this->config->update('timer', $name, $value);
    }

    /**
     * @param $needle
     * @return mixed
     */
    private function getItems($needle)
    {
        $items = [];
        $services = [];

        foreach ($this->config->implementedServicesForFeature('get_' . $needle) as $service) {
            if ($this->config->isServiceActive($service) === true) {
                $services[$service] = $this->$service->getTags($this->getServiceDataCache($service));
            }
        }

        foreach ($services as $serviceName => $serviceItems) {
            foreach ($serviceItems as $serviceItem) {
                $items[$serviceItem['name']][$serviceName . '_id'] = $serviceItem['id'];
            }
        }

        return $items;
    }

    /**
     * @param  $name
     * @return mixed
     */
    private function getProperty($name)
    {
        return $this->config->get('timer', $name);
    }

    /**
     * @return mixed
     */
    private function getRecentServiceTimers($service)
    {
        return $this->$service->getRecentTimers();
    }

    /**
     * @param $data
     * @param string  $service
     */
    private function saveServiceDataCache($service, $data)
    {
        $cacheFile = getenv('alfred_workflow_data') . '/' . $service . '_cache.json';
        file_put_contents($cacheFile, json_encode($data));
    }

    /**
     * @param  string   $service
     * @return string
     */
    private function syncServiceOnlineDataToLocalCache($service)
    {
        $data = $this->$service->getOnlineData();

        if (empty($data) === true) {
            return $this->setNotificationForService($service, 'data', false);
        }

        $this->saveServiceDataCache($service, $data);

        return $this->setNotificationForService($service, 'data', true);
    }
}