Clubdeuce\Tessitura\Resources\Performances

Complexity

Total Complexity

15

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

83.05%

Importance

Changes	6
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getPerformancesBetween()	0	22	4
A	getUpcomingPerformances()	0	9	2
A	search()	0	19	3
A	getPerformanceZoneAvailabilities()	0	12	3
A	getPerformancesForProductionSeason()	0	4	1
A	makeNewZoneAvailability()	0	14	1

<?php

namespace Clubdeuce\Tessitura\Resources;

use Clubdeuce\Tessitura\Base\Base;
use Clubdeuce\Tessitura\Interfaces\ApiInterface;
use Clubdeuce\Tessitura\Interfaces\ResourceInterface;
use DateTime;
use Exception;

class Performances extends Base implements ResourceInterface
{
    const RESOURCE = 'TXN/Performances';
    protected ApiInterface $_api;

    public function __construct(ApiInterface $api)
    {
        $this->_api = $api;
        parent::__construct();
    }

    public function getUpcomingPerformances(int $days = 30): array
    {
        try {
            $start = new DateTime();
            $end = new DateTime("now + {$days} days");

            return $this->getPerformancesBetween($start, $end);
        } catch (Exception $e) {
            throw new Exception("Unable to get upcoming performances: " . $e->getMessage());
        }
    }

    public function getPerformancesBetween(DateTime $start, DateTime $end): array
    {
        $sorted = [];
        $performances = $this->search([
            'PerformanceStartDate' => $start->format(DATE_ATOM),
            'PerformanceEndDate' => $end->format(DATE_ATOM),
        ]);

        foreach ($performances as $performance) {
            try {
                $date = $performance->date();
                if (!is_null($date)) {
                    $sorted[$date->getTimestamp()] = $performance;
                }
            } catch (Exception $e) {
                // Skip performances with invalid dates rather than stopping the entire operation
                continue;
            }
        }

        ksort($sorted);
        return $sorted;
    }

    public function getPerformancesForProductionSeason(int $psId): array
    {
        return $this->search([
            'ProductionSeasonIds' => (string)$psId,
        ]);
    }

    /**
     * @param  array $args
     * @return Performance[]
     */
    public function search(array $args = []): array
    {
        $endpoint = sprintf('%1$s/Search', self::RESOURCE);
        $body = json_encode($args);

        $args = [
            'body' => $body,
            'headers' => [
                'Content-Length' => $body ? strlen($body) : 0,
            ]
        ];

        $results = $this->_api->post($endpoint, $args);

        if (!is_array($results)) {
            return [];
        }

        return array_map(fn($item) => new Performance($item), $results);
    }

    public function getPerformanceZoneAvailabilities(int $performanceId): array
    {
        try {
            $data = $this->_api->get(sprintf('%1$s/Zones?performanceIds=%2$s', self::RESOURCE, $performanceId));

            if (is_array($data)) {
                return array_map([$this, 'makeNewZoneAvailability'], $data);
            }

            return [];
        } catch (Exception $e) {
            return [];
        }
    }

    protected function makeNewZoneAvailability(array $data): PerformanceZoneAvailability
    {
        $data = $this->parseArgs($data, [
            'AvailableCount' => 0,
            'Id' => 0,
            'Inactive' => false,
            'PerformanceId' => 0,
            'SectionSummaries' => null,
            'Zone' => null,
        ]);

        return new PerformanceZoneAvailability([
            'availableCount' => $data['AvailableCount'],
            'zone' => $data['Zone'],
        ]);
    }
}