AlfredTime\Time

Complexity

Total Complexity

63

Size/Duplication

Total Lines	447
Duplicated Lines	3.58 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	9
Bugs	0	Features	0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	activatedServices()	0	12	3
A	deleteTimer()	0	19	4
A	generateDefaultConfigurationFile()	0	4	1
A	getProjectName()	0	15	3
A	deleteServiceTimer()	0	13	3
A	getTogglTags()	0	11	2
A	saveTogglDataCache()	0	5	1
A	syncTogglOnlineDataToLocalCache()	0	12	2
B	getProjects()	0	35	6
A	getRecentTimers()	0	10	2
A	getTags()	0	10	2
A	getTimerDescription()	0	4	1
A	hasTimerRunning()	0	4	2
A	implementedServicesForFeature()	0	10	2
A	isConfigured()	0	4	2
A	isServiceActive()	0	4	1
A	servicesToUndo()	0	12	3
D	startTimer()	0	41	9
A	startTimerWithDefaultOptions()	0	14	1
A	stopRunningTimer()	9	21	4
A	syncOnlineDataToLocalCache()	0	10	2
B	undoTimer()	7	24	5
A	getRecentTogglTimers()	0	4	1

<?php

namespace AlfredTime;

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

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

    /**
     * @var array
     */
    private $currentImplementation = [
        'start'         => ['toggl'],
        'start_default' => ['toggl', 'harvest'],
        'stop'          => ['toggl', 'harvest'],
        'delete'        => ['toggl'],
    ];

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

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

    /**
     * @var array
     */
    private $services = [
        'toggl',
        'harvest',
    ];

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

    public function __construct()
    {
        $this->config = new Config(getenv('alfred_workflow_data') . '/config.json');

        $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'));
        $this->message = '';
    }

    /**
     * @return mixed
     */
    public function activatedServices()
    {
        $activatedServices = [];

        foreach ($this->services as $service) {
            if ($this->isServiceActive($service) === true) {
                array_push($activatedServices, $service);
            }
        }

        return $activatedServices;
    }

    /**
     * @param  $service
     * @param  $timerId
     * @return boolean
     */
    public function deleteServiceTimer($service, $timerId)
    {
        $res = false;

        if ($this->$service->deleteTimer($timerId) === true) {
            if ($timerId === $this->config->get('workflow', 'timer_' . $service . '_id')) {
                $this->config->update('workflow', 'timer_' . $service . '_id', null);
                $res = true;
            }
        }

        return $res;
    }

    /**
     * @param  $timerId
     * @return string
     */
    public function deleteTimer($timerId)
    {
        $message = '';
        $atLeastOneTimerDeleted = false;

        foreach ($this->implementedServicesForFeature('delete') as $service) {
            if ($this->deleteServiceTimer($service, $timerId) === true) {
                $atLeastOneTimerDeleted = true;
            }

            $message .= $this->$service->getLastMessage() . "\r\n";
        }

        if ($atLeastOneTimerDeleted === true) {
            $this->config->update('workflow', 'is_timer_running', false);
        }

        return $message;
    }

    public function generateDefaultConfigurationFile()
    {
        $this->config->generateDefaultConfigurationFile();
    }

    /**
     * @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()
    {
        $services = ['toggl'];

$services is not used, you could remove the assignment.

        $tempServices = ['toggl'];
        $projects = [];

/*
 * Temporary, only get the projects of Toggl
 * Later, we will get Harvest ones too
 */
        foreach ($tempServices as $service) {
            if ($this->isServiceActive($service) === true) {
                $cacheFile = getenv('alfred_workflow_data') . '/' . $service . '_cache.json';

                if (file_exists($cacheFile)) {
                    $projects = json_decode(file_get_contents($cacheFile), true);

/*
 * To only show projects that are currently active
 * The Toggl API is slightly weird on that
 */
                    foreach ($projects['data']['projects'] as $key => $project) {
                        if (isset($project['server_deleted_at']) === true) {
                            unset($projects['data']['projects'][$key]);
                        }
                    }

                    $projects = $projects['data']['projects'];
                }
            }
        }

        return $projects;
    }

    /**
     * @return mixed
     */
    public function getRecentTimers()
    {
        $timers = [];

        if ($this->isServiceActive('toggl') === true) {
            $timers = array_merge($timers, $this->getRecentTogglTimers());
        }

        return $timers;
    }

    /**
     * @return mixed
     */
    public function getTags()
    {
        $tags = [];

        if ($this->isServiceActive('toggl') === true) {
            $tags = array_merge($tags, $this->getTogglTags());
        }

        return $tags;
    }

    /**
     * @return mixed
     */
    public function getTimerDescription()
    {
        return $this->config->get('workflow', 'timer_description');
    }

    /**
     * @return boolean
     */
    public function hasTimerRunning()
    {
        return $this->config->get('workflow', 'is_timer_running') === false ? false : true;
    }

    /**
     * @param  string  $feature
     * @return mixed
     */
    public function implementedServicesForFeature($feature = null)
    {
        $services = [];

        if (isset($this->currentImplementation[$feature]) === true) {
            $services = $this->currentImplementation[$feature];
        }

        return $services;
    }

    /**
     * @return boolean
     */
    public function isConfigured()
    {
        return $this->config === null ? false : true;
    }

    /**
     * @param  $service
     * @return mixed
     */
    public function isServiceActive($service)
    {
        return $this->config->get($service, 'is_active');
    }

    /**
     * @return mixed
     */
    public function servicesToUndo()
    {
        $services = [];

        foreach ($this->activatedServices() as $service) {
            if ($this->config->get('workflow', 'timer_' . $service . '_id') !== null) {
                array_push($services, $service);
            }
        }

        return $services;
    }

    /**
     * @param  $description
     * @param  $projectsDefault
     * @param  null               $tagsDefault
     * @param  boolean            $startDefault
     * @return string
     */
    public function startTimer($description = '', $projectsDefault = null, $tagsDefault = null, $startDefault = false)
    {
        $message = '';
        $startType = $startDefault === true ? 'start_default' : 'start';
        $atLeastOneServiceStarted = false;
        $implementedServices = $this->implementedServicesForFeature($startType);

/*
 * 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($implementedServices) === false) {
            foreach ($this->activatedServices() as $service) {
                $this->config->update('workflow', 'timer_' . $service . '_id', null);
            }

            foreach ($implementedServices as $service) {
                $defaultProjectId = isset($projectsDefault[$service]) ? $projectsDefault[$service] : null;
                $defaultTags = isset($tagsDefault[$service]) ? $tagsDefault[$service] : null;

                $timerId = $this->$service->startTimer($description, $defaultProjectId, $defaultTags);
                $this->config->update('workflow', 'timer_' . $service . '_id', $timerId);

                if ($timerId !== null) {
                    $atLeastOneServiceStarted = true;
                }

                $message .= $this->$service->getLastMessage() . "\r\n";
            }
        }

        if ($atLeastOneServiceStarted === true) {
            $this->config->update('workflow', 'timer_description', $description);
            $this->config->update('workflow', 'is_timer_running', true);
        }

        return $message;
    }

    /**
     * @param  $description
     * @return string
     */
    public function startTimerWithDefaultOptions($description)
    {
        $projectsDefault = [
            'toggl'   => $this->config->get('toggl', 'default_project_id'),
            'harvest' => $this->config->get('harvest', 'default_project_id'),
        ];

        $tagsDefault = [
            'toggl'   => $this->config->get('toggl', 'default_tags'),
            'harvest' => $this->config->get('harvest', 'default_task_id'),
        ];

        return $this->startTimer($description, $projectsDefault, $tagsDefault, true);
    }

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

        foreach ($this->activatedServices() as $service) {

This code seems to be duplicated across your project.

            $timerId = $this->config->get('workflow', 'timer_' . $service . '_id');

            if ($this->$service->stopTimer($timerId) === true) {
                $atLeastOneServiceStopped = true;
            }

            $message .= $this->$service->getLastMessage() . "\r\n";
        }

        if ($atLeastOneServiceStopped === true) {
            $this->config->update('workflow', 'is_timer_running', false);
        }

        return $message;
    }

    /**
     * @return string
     */
    public function syncOnlineDataToLocalCache()
    {
        $message = '';

        if ($this->isServiceActive('toggl') === true) {
            $message .= $this->syncTogglOnlineDataToLocalCache();
        }

        return $message;
    }

    /**
     * @return string
     */
    public function undoTimer()
    {
        $message = '';

        if ($this->hasTimerRunning() === true) {
            $this->stopRunningTimer();
        }

        $atLeastOneTimerDeleted = false;

        foreach ($this->servicesToUndo() as $service) {

This code seems to be duplicated across your project.

            if ($this->deleteServiceTimer($service, $this->config->get('workflow', 'timer_' . $service . '_id')) === true) {
                $atLeastOneTimerDeleted = true;
            }

            $message .= $this->$service->getLastMessage() . "\r\n";
        }

        if ($atLeastOneTimerDeleted === true) {
            $this->config->update('workflow', 'is_timer_running', false);
        }

        return $message;
    }

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

    /**
     * @return mixed
     */
    private function getTogglTags()
    {
        $cacheFile = getenv('alfred_workflow_data') . '/toggl_cache.json';
        $cacheData = [];

        if (file_exists($cacheFile)) {
            $cacheData = json_decode(file_get_contents($cacheFile), true);
        }

        return $cacheData['data']['tags'];
    }

    /**
     * @param $data
     */
    private function saveTogglDataCache($data)
    {
        $cacheFile = getenv('alfred_workflow_data') . '/toggl_cache.json';
        file_put_contents($cacheFile, json_encode($data));
    }

    /**
     * @return mixed
     */
    private function syncTogglOnlineDataToLocalCache()
    {
        $data = $this->toggl->getOnlineData();

        $this->message = $this->toggl->getLastMessage();

        if (empty($data) === false) {
            $this->saveTogglDataCache($data);
        }

        return $this->message;
    }
}