Godbout\Alfred\Time\Services\Clockify

Complexity

Total Complexity

21

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Test Coverage

Coverage

91.76%

Importance

Changes	2
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	projects()	0	16	2
A	stopCurrentTimer()	0	23	3
A	tags()	0	11	2
A	startTimer()	0	24	4
A	runningTimer()	0	16	2
A	convertToPastTimers()	0	8	1
A	pastTimers()	0	16	2
A	continueTimer()	0	7	1
A	buildPastTimerObject()	0	20	3

<?php

namespace Godbout\Alfred\Time\Services;

use Carbon\Carbon;
use Godbout\Alfred\Time\Workflow;
use GuzzleHttp\Client;

class Clockify extends TimerService
{
    private $client;


    public function __construct($apiToken)
    {
        $this->client = new Client([
            'base_uri' => 'https://api.clockify.me/api/v1/',
            'headers' => [
                'content-type' => 'application/json',
                'X-Api-Key' => $apiToken
            ]
        ]);
    }

    public function projects()
    {
        try {
            $user = json_decode(
                $this->client->get("user")->getBody()->getContents()
            );

            Workflow::getConfig()->write('clockify.active_workspace_id', $user->activeWorkspace);

            $response = $this->client->get("workspaces/{$user->activeWorkspace}/projects");

            $projects = json_decode($response->getBody()->getContents());

            return array_column($projects, 'name', 'id');
        } catch (\Exception $e) {
            return [];
        }
    }

    public function tags()
    {
        try {
            $workspaceId = Workflow::getConfig()->read('clockify.active_workspace_id');

            $response = $this->client->get("workspaces/$workspaceId/tags");
            $tags = json_decode($response->getBody()->getContents());

            return array_column($tags, 'name', 'id');
        } catch (\Exception $e) {
            return [];
        }
    }

    public function startTimer()
    {
        try {
            $workspaceId = Workflow::getConfig()->read('clockify.active_workspace_id');

            $response = $this->client->post("workspaces/$workspaceId/time-entries", [
                'json' => [
                    'start' => (new \DateTime())->format('Y-m-d\TH:i:s\Z'),
                    'description' => getenv('timer_description'),
                    'projectId' => getenv('timer_project_id'),
                    'tagIds' => getenv('timer_tag_id') ? [getenv('timer_tag_id')] : [''],
                ]
            ]);

            $timer = json_decode($response->getBody()->getContents());

            if (! isset($timer->id)) {
                return false;
            }
        } catch (\Exception $e) {
            return false;
        }

        return $timer->id;
    }

    public function stopCurrentTimer()
    {
        $user = json_decode(
            $this->client->get("user")->getBody()->getContents()
        );

        if ($this->runningTimer()) {
            $response = $this->client->patch("workspaces/{$user->activeWorkspace}/user/{$user->id}/time-entries", [
                'json' => [
                    'end' => (new \DateTime())->format('Y-m-d\TH:i:s\Z'),
                ]
            ]) ;

            $timer = json_decode($response->getBody()->getContents());

            if (! isset($timer->timeInterval->end)) {
                throw new \Exception("Can't stop current running timer.", 1);
            }

            return true;
        }

        return false;
    }

    public function runningTimer()
    {
        try {
            $user = json_decode(
                $this->client->get("user")->getBody()->getContents()
            );

            $response = $this->client->get(
                "workspaces/{$user->activeWorkspace}/user/{$user->id}/time-entries?in-progress=true"
            );

            $timer = json_decode($response->getBody()->getContents());

            return $timer[0]->id ?? false;
        } catch (\Exception $e) {
            return false;
        }
    }

    public function pastTimers()
    {
        try {
            $user = json_decode(
                $this->client->get("user")->getBody()->getContents()
            );

            $response = $this->client->get("workspaces/{$user->activeWorkspace}/user/{$user->id}/time-entries", [
                'start' => Carbon::today(),
                'end' => Carbon::today()->subDays(30),
            ]);
            $clockifyTimers = json_decode($response->getBody()->getContents());

            return $this->convertToPastTimers($clockifyTimers);
        } catch (\Exception $e) {
            return [];
        }
    }

    public function continueTimer($timerId = null)
    {
        /**
         * Timer attributes are stored in env variables
         * gathered in startTimer.
         */
        return $this->startTimer();
    }

    protected function convertToPastTimers($clockifyTimers)
    {
        $projects = $this->projects();
        $tags = $this->tags();

        return array_map(function ($clockifyTimer) use ($projects, $tags) {
            return $this->buildPastTimerObject($clockifyTimer, $projects, $tags);
        }, $clockifyTimers);
    }

    protected function buildPastTimerObject($clockifyTimer, $projects, $tags)
    {
        $pastTimer = [];

        $pastTimer['id'] = $clockifyTimer->id;
        $pastTimer['description'] = $clockifyTimer->description;

        if (isset($clockifyTimer->projectId)) {
            $pastTimer['project_id'] = $clockifyTimer->projectId;
            $pastTimer['project_name'] = $projects[$clockifyTimer->projectId];
        }

        if (isset($clockifyTimer->tagIds[0])) {
            $pastTimer['tag_id'] = $clockifyTimer->tagIds[0];
            $pastTimer['tags'] = $tags[$clockifyTimer->tagIds[0]];
        }

        $pastTimer['duration'] = $clockifyTimer->timeInterval->duration;

        return (object) $pastTimer;
    }
}