Bookwhen::event() - Code Metrics - Inspection of "scrutinizer" - inshore/bookwhen - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — develop (#83)

unknown
created 2023-04-24 16:40 UTC
Bookwhen::event() B

↳ Parent: Bookwhen
Complexity

Conditions	7
Paths	9
Size

Total Lines	96
Code Lines	58
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	7
eloc	58
c	1
b	0
f	0
nc	9
nop	6
dl	0
loc	96
rs	7.983
How to fix Long Method

<?php

declare(strict_types=1);

namespace InShore\Bookwhen;

use InShore\Bookwhen\BookwhenApi;
use InShore\Bookwhen\Client;
use InShore\Bookwhen\Domain\Attachment;
use InShore\Bookwhen\Domain\ClassPass;
filter:
    dependency_paths: ["lib/*"]
use InShore\Bookwhen\Domain\Event;
use InShore\Bookwhen\Domain\Location;
use InShore\Bookwhen\Domain\Ticket;
use InShore\Bookwhen\Exceptions\ValidationException;
use InShore\Bookwhen\Interfaces\BookwhenInterface;
use InShore\Bookwhen\Validator;
use Monolog\Level;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

final class Bookwhen implements BookwhenInterface
{
    private null | Client $client;

    /**
     *
     * @var unknown
filter:
    dependency_paths: ["lib/*"]
     */
    public Attachment $attachment;

    /**
     *
     * @var unknown
     */
    public array $attachments = [];

    /**
     *
     * @var unknown
     */
    public ClassPass $classPass;

    /**
     *
     * @var unknown
     */
    public array $classPasses = [];

    /**
     *
     * @var unknown
     */
    public Event $event;

    /**
     *
     * @var unknown
     */
    public array $events = [];

    /**
     *
     * @var unknown
     */
    private array $filters = [];
    
    /**
     *
     */
    public readonly Location $location;

    /**
     *
     * @var unknown
     */
    private array $includes = [];
    /**

     */
    public Ticket $ticket;

    /**

     */
    public array $tickets = [];

    /**
        *
     */
    public $locations = [];


    /** @var string The path to the log file */
    private $logFile;


    /** @var object loging object. */
    private $logger;


    /** @var string the logging level. */
    private string $logLevel;




    /**
     * Creates a new Bookwhen Client with the given API token.
     * @todo logging
     */
    public function __construct(
        private $validator = new Validator()
    ) {
        //         $this->logFile = $logFile;
        //         $this->logLevel = $logLevel;
        //         $this->logger = new Logger('inShore Bookwhen API');
        //         $this->logger->pushHandler(new StreamHandler($this->logFile, $this->logLevel));
        $this->client = BookwhenApi::client($_ENV['INSHORE_BOOKWHEN_API_KEY']);
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::attachment()
     * @todo all attachment properties
     */
    public function attachment(string $attachmentId): Attachment
    {
        if (!$this->validator->validId($attachmentId, 'attachment')) {
            throw new ValidationException('attachmentId', $attachmentId);
        }

        $attachment = $this->client->attachments()->retrieve($attachmentId);
        $attachment = $this->client->/** @scrutinizer ignore-call */ attachments()->retrieve($attachmentId);

        return $this->attachment = new Attachment(
        return $this->attachment = /** @scrutinizer ignore-call */ new Attachment(
            $attachment->id,
            $attachment->title,
        );
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\BookwhenInterface::attachment()
     * @todo
     */
    public function attachments(
        string $title = null,
        string $fileName = null,
        string $fileType = null
    ): array {
        //$this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        if (!is_null($title) && !$this->validator->validTitle($title)) {
            throw new ValidationException('title', $title);
        }

        if (!is_null($fileName) && !$this->validator->validFileName($fileName)) {
            throw new ValidationException('file name', $fileName);
        }

        if (!is_null($fileType) && !$this->validator->validFileType($fileType)) {
            throw new ValidationException('file type', $fileType);
        }

        $attachments = $this->client->attachments()->list();

        foreach ($attachments->data as $attachment) {
            array_push($this->attachment, new Attachment(
            array_push($this->attachment, /** @scrutinizer ignore-call */ new Attachment(
                $attachment->id,
            ));
        }

        return $this->attachments;
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::getClassPass()
     * @todo
     */
    public function classPass(string $classPassId): ClassPass
    {
        //         $this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        //       if (!$this->validator->validId($classPassId, 'classPass')) {
        //           throw new ValidationException('classPassId', $classPassId);
        //      }

        $classPass = $this->client->classPasses()->retrieve($classPassId);

        return new ClassPass(
            $classPass->details,
            $classPass->id,
            $classPass->number_available,
            $classPass->title,
            $classPass->usage_allowance,
            $classPass->usage_type,
            $classPass->use_restricted_for_days
        );
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::getClassPasses()
     * @todo break params on to multiplper lines..
     */
    public function classPasses(
        $title = null,
        $detail = null,
        $usageType = null,
        $cost = null,
        $usageAllowance = null,
        $useRestrictedForDays = null
    ): array {

        //$this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        if (!is_null($title) && !$this->validator->validTitle($title)) {
            throw new ValidationException('title', $title);
        }

        // @todo remaingin validation

        $classPasses = $this->client->classPasses()->list([]);
        $classPasses = $this->client->classPasses()->/** @scrutinizer ignore-call */ list([]);

        foreach ($classPasses->data as $classPass) {
            array_push($this->classPasses, new classPasses(
filter:
    dependency_paths: ["lib/*"]
                $ticket->details,

                $ticket->id,
                $ticket->title
            ));
        }
        return $this->classPasses;
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\BookwhenInterface::event()
     * @todo filters.
     */
    public function event(
        string $eventId, 
        bool $attachments = false,
        bool $location = false,
        bool $tickets = false,
        bool $ticketsClassPasses = false,
        bool $ticketsEventslocation = false
    ): Event
    {
        //$this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        if (!$this->validator->validId($eventId, 'event')) {
            throw new ValidationException('eventId', $eventId);
        }

        $event = $this->client->events()->retrieve($eventId);
            
        $eventAttachments = [];
        $eventTickets = [];
        
        // attachments
        if($attachments) {
            foreach ($event->attachments as $eventAttachment) {
                $attachment = $this->client->attachments()->retrieve($eventAttachment['id']);
                array_push($eventAttachments, new Attachment(
                array_push($eventAttachments, /** @scrutinizer ignore-call */ new Attachment(
                    $attachment->id,
                    $attachment->title,
                ));
            }
        }

        // location
        // @todo resolve dynamic type
        if(!$location) {
            $eventLocation = new Location(
                null,
                null,
                $event->locationId
            );
        }
        else {
            $location = $this->client->locations()->retrieve($event->locationId);
            $eventLocation = new Location(
                $location->addressText,
                $location->additionalInfo,
                $location->id,
                $location->latitude,
                $location->longitude,
                $location->mapUrl,
                $location->zoom
            );
        }
        
        // tickets
        if($tickets) {
            foreach ($event->tickets as $eventTicket) {
                $ticket = $this->client->tickets()->retrieve($eventTicket['id']);
                array_push($eventTickets, new Ticket(
                    $ticket->available,
                    $ticket->availableFrom,
                    $ticket->availableTo,
                    $ticket->builtBasketUrl,
                    $ticket->builtBasketIframeUrl,
                    $ticket->courseTicket,
                    $ticket->details,
                    $ticket->groupTicket,
                    $ticket->groupMin,
                    $ticket->groupMax,
                    $ticket->id,
                    $ticket->numberIssued,
                    $ticket->numberTaken,
                    $ticket->title
                ));
            }
        }
        
        // ticketsClassPasses
        // @todo
        
        // ticketsEvents
        // @todo
        
        return $this->event = new Event(

            $event->allDay,
            $eventAttachments,
            $event->attendeeCount,
            $event->attendeeLimit,
            $event->details,
            $event->endAt,
            $event->id,
            $eventLocation,
            $event->maxTicketsPerBooking,
            $event->startAt,
            $eventTickets,
            $event->title,
            $event->waitingList
         );
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::getEvents()
     */
    public function Events(
        $calendar = false, 
        $entry = false, 
        $location = [], 
        $tags = [],
        $title = [], 
        $detail = [], 
        $from = null, 
        $to = null, 
        $includeAttachments = false,
        $includeLocation = false,
        $includeTickets = false, 
        $includeTicketsClassPasses = false,
        $includeTicketsEvents = false
    ): array {

        //$this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        // Validate $calendar
        // @todo details required
        
        // Validate $detail
        if (!empty($detail)) {
            if (!is_array($detail)) {
                throw new ValidationException('detail', implode(' ', $detail));
            } else {
                $detail = array_unique($detail);
                foreach($detail as $item) {
                    if (!$this->validator->validLocation($item)) {
                        throw new ValidationException('detail', $item);
                    }
                }
                $this->filters['filter[detail]'] = implode(',', $detail);
            }
        }

        // Validate $entry
        // @todo details required
        
        // Validate $from;
        if (!empty($from)) {
            if (!$this->validator->validFrom($from, $to)) {
                throw new ValidationException('from', $from . '-' . $to);
            } else {
                $this->filters['filter[from]'] = $from;
            }
        }

        // Validate $location
        if (!empty($location)) {
            if (!is_array($location)) {
                throw new ValidationException('location', implode(' ', $title));
            } else {
                $location = array_unique($location);
                foreach($location as $item) {
                    if (!$this->validator->validLocation($item)) {
                        throw new ValidationException('location', $item);
                    }
                }
                $this->filters['filter[location]'] = implode(',', $location);
            }
        }
        
        // Validate $tags.
        if (!empty($tags)) {
            if (!is_array($tags)) {
                throw new ValidationException('tags', implode(' ', $tags));
            } else {
                $tags = array_unique($tags);
                foreach ($tags as $tag) {
                    if (!empty($tag) && !$this->validator->validTag($tag)) {
                        throw new ValidationException('tag', $tag);
                    }
                }
            }
            $this->filters['filter[tag]'] = implode(',', $tags);
        }

        // Validate $title;
        if (!empty($title)) {
            if (!is_array($title)) {
                throw new ValidationException('title', implode(' ', $title));
            } else {
                $title = array_unique($title);
                foreach($title as $item) {
                    if (!$this->validator->validTitle($item)) {
                        throw new ValidationException('title', $item);
                    }
                }
                $this->filters['filter[title]'] = implode(',', $title);
            }
        }
        
        // Validate $to;
        if (!empty($to)) {
            if (!$this->validator->validTo($to, $from)) {
                throw new ValidationException('to', $to . '-' . $from);
            } else {
                $this->filters['filter[to]'] = $to;
            }
        }
        
        // Validate $includeAttachments;      
        if (!$this->validator->validInclude($includeAttachments)) {
            throw new ValidationException('includeAttachments', $includeAttachments);
        } else {
            if($includeAttachments) {
                array_push($this->includes, 'attachments');
            }
        }
        
        // Validate $includeTickets;
        if (!$this->validator->validInclude($includeLocation)) {
            throw new ValidationException('includeLocation', $includeLocation);
        } else {
            if($includeLocation) {
                array_push($this->includes, 'location');
            }
        }
        
        // Validate $includeTickets;
        if (!$this->validator->validInclude($includeTickets)) {
            throw new ValidationException('includeTickets', $includeTickets);
        } else {
            if($includeTickets) {
                array_push($this->includes, 'tickets');
            }
        }
        
        // Validate $includeTicketsEvents;
        if (!$this->validator->validInclude($includeTicketsEvents)) {
            throw new ValidationException('includeTicketsEvents', $includeTicketsEvents);
        } else {
            if($includeTickets) {
                array_push($this->includes, 'tickets.events');
            }
        }
        
        // Validate $includeTicketsClassPasses;
        if (!$this->validator->validInclude($includeTicketsClassPasses)) {
            throw new ValidationException('includeTicketsClassPasses', $includeTicketsClassPasses);
        } else {
            if($includeTicketsClassPasses) {
                array_push($this->includes, 'tickets.class_passes');
            }
        }
        
        $events = $this->client->events()->list(array_merge($this->filters, ['include' => implode(',', $this->includes)]));
        
        $eventAttachments = [];
        
        $eventTickets = [];

        foreach ($events->data as $event) {
            array_push($this->events, new Event(
                $event->allDay,
                $eventAttachments,
                $event->attendeeCount,
                $event->attendeeLimit,
                $event->details,
                $event->endAt,
                $event->id,
                new Location( 
                    null,
                    null, 
                    $event->locationId,
                ),
                $event->maxTicketsPerBooking,
                $event->startAt,
                $eventTickets,
                $event->title,
                $event->waitingList
            ));
        }

        return $this->events;
    }

    /*
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::getLocation()
     */
    public function location(string $locationId): Location
    {

        if (!$this->validator->validId($locationId, 'location')) {
            throw new ValidationException('locationId', $locationId);
        }

        $location = $this->client->locations()->retrieve($locationId);

        return $this->location = new Location(

            $location->additionalInfo,
            $location->addressText,
            $location->id,
            $location->latitude,
            $location->longitude,
            $location->mapUrl,
            $location->zoom
        );
    }

    /**
     *
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\ClientInterface::getLocations()
     * @todo validate params.
     */
    public function locations(
        null | string $addressText = null,
        null | string $additionalInfo = null
    ): array {

        // $this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        if (!$this->validator->validId($eventId, 'event')) {

            throw new ValidationException('eventId', $eventId);
        }

        $locations = $this->client->locations()->list();

        foreach ($locations->data as $location) {
            array_push($this->locations, new Location(
                $location->additionalInfo,
                $location->addressText,
                $location->id,
                $location->latitude,
                $location->longitude,
                $location->mapUrl,
                $location->zoom
            ));
        }

        return $this->locations;

    }

    /**
     * Set Debug.
     * @deprecated
     */
    public function setLogging($level)
    {
        $this->logging = $level;

    }

     /**
     * Sets the token for all future new instances
     * @deprecated
     * @param $token string The API access token, as obtained on diffbot.com/dev.
     */
    public static function setToken($token)
    {
        $validator = new Validator();
        if (!$validator->validToken($token)) {
            throw new \InvalidArgumentException('Invalid Token.');
        }
        self::$token = $token;

    }

    /**
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\BookWhenInterface::ticket()
     */
    public function ticket($ticketId): Ticket
    {
        if (!$this->validator->validId($ticketId, 'ticket')) {
            throw new ValidationException('ticketId', $ticketId);
        }

        $ticket = $this->client->tickets()->retrieve($ticketId);

        return $this->ticket = new Ticket(
            $ticket->available,
            $ticket->availableFrom,
            $ticket->availableTo,
            $ticket->builtBasketUrl,
            $ticket->builtBasketIframeUrl,
            $ticket->courseTicket,
            $ticket->details,
            $ticket->groupTicket,
            $ticket->groupMin,
            $ticket->groupMax,
            $ticket->id,
            $ticket->numberIssued,
            $ticket->numberTaken,
            $ticket->title
        );
    }

    /**
     * {@inheritDoc}
     * @see \InShore\Bookwhen\Interfaces\BookWhenInterface::tickets()
     * @todo includes
     */
    public function tickets(string $eventId): array
    {
        // $this->logger->debug(__METHOD__ . '(' . var_export(func_get_args(), true) . ')');

        if (!$this->validator->validId($eventId, 'event')) {
            throw new ValidationException('eventId', $eventId);
        }

        $tickets = $this->client->tickets()->list([
            'event_id' => $eventId,
            'include' => 'events.tickets'
        ]);

        foreach ($tickets->data as $ticket) {
            array_push($this->tickets, new Ticket(
                $ticket->available,
                $ticket->availableFrom,
                $ticket->availableTo,
                $ticket->builtBasketUrl,
                $ticket->builtBasketIframeUrl,
                $ticket->courseTicket,
                $ticket->details,
                $ticket->groupTicket,
                $ticket->groupMin,
                $ticket->groupMax,
                $ticket->id,
                $ticket->numberIssued,
                $ticket->numberTaken,
                $ticket->title
            ));
        }

        return $this->tickets;

    }
}

inshore / bookwhen

Pull Request — develop (#83)

Bookwhen::event() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
