smtech\CanvasICSSync\SyncIntoCanvas\Calendar

Complexity

Total Complexity

36

Size/Duplication

Total Lines	397
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	8
Bugs	1	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	setContext()	0	10	2
A	getContext()	0	4	1
A	setFeedUrl()	0	13	3
A	getFeedUrl()	0	4	1
A	setName()	0	4	1
A	getName()	0	4	1
A	setFilter()	0	4	1
A	getFilter()	0	4	1
A	getId()	0	4	1
A	getContextCode()	0	4	1
A	save()	0	59	2
A	load()	0	17	2
A	delete()	0	7	1
D	sync()	0	82	13
A	log()	0	6	2
A	logThrow()	0	11	2

<?php

namespace smtech\CanvasICSSync\SyncIntoCanvas;

use DateTime;
use Exception;
use vcalendar;
use Battis\DataUtilities;
use smtech\CanvasICSSync\SyncIntoCanvas\Transform\Transform;
use smtech\CanvasICSSync\SyncIntoCanvas\Filter\Filter;

class Calendar
{
    /**
     * Canvas calendar context
     * @var CalendarContext
     */
    protected $context;

    /**
     * ICS or webcal feed URL
     * @var string
     */
    protected $feedUrl;

    /**
     * Name of this calendar (extracted from feed)
     * @var string
     */
    protected $name;

    /**
     * Transformations for events in this calendar_event
     * @var Transform[]
     */
    protected $transforms;

    /**
     * Filters for events in this calendar
     * @var Filter[]
     */
    protected $filters;

    /**
     * Construct a Calendar object
     *
     * @param string $canvasUrl URL of a Canvas calendar context
     * @param string $feedUrl URL of a webcal or ICS calendar feed
     * @param boolean $enableFilter (Optional, default `false`)
     * @param string $include (Optional) Regular expression to select events
     *     for inclusion in the calendar sync
     * @param string $exclude (Optional) Regular expression to select events
     *     for exclusion from the calendar sync
     */
    public function __construct($canvasUrl, $feedUrl, $enableFilter = false, $include = null, $exclude = null)
    {
        $this->setContext(new CalendarContext($canvasUrl));
        $this->setFeedUrl($feedUrl);
        $this->setFilter(new Filter(
            $enableFilter,

The call to Filter::__construct() has too many arguments starting with $enableFilter.

            $include,
            $exclude
        ));
    }

    /**
     * Set the Canvas calendar context
     *
     * @param CalendarContext $context
     * @throws Exception If `$context` is null
     */
    public function setContext(CalendarContext $context)
    {
        if (!empty($context)) {
            $this->context = $context;
        } else {
            throw new Exception(
                'Context cannot be null'
            );
        }
    }

    /**
     * Get the Canvas calendar context
     *
     * @return CalendarContext
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * Set the webcal or ICS feed URl for this calendar
     *
     * @param string $feedUrl
     * @throws Exception If `$feedUrl` is not a valid URL
     */
    public function setFeedUrl($feedUrl)
    {
        if (!empty($feedUrl)) {
            /* crude test to see if the feed is a valid URL */
            $handle = fopen($feedUrl, 'r');
            if ($handle !== false) {
                $this->feedUrl = $feedUrl;
            }
        }
        throw new Exception(
            'Feed must be a valid URL'
        );
    }

    /**
     * Get the feed URL for this calendar
     *
     * @return string
     */
    public function getFeedUrl()
    {
        return $this->feedUrl;
    }

    /**
     * Set the name of the calendar
     *
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = (string) $name;
    }

    /**
     * Get the name of the calendar
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set the regular expression filter for this calendar
     *
     * @param Filter $filter
     */
    public function setFilter(Filter $filter)
    {
        $this->filter = $filter;

The property filter does not seem to exist. Did you mean filters?

    }

    /**
     * Get the regular expression filter for this calendar
     *
     * @return Filter
     */
    public function getFilter()
    {
        return $this->filter;

The property filter does not seem to exist. Did you mean filters?

    }

    /**
     * Generate a unique ID to identify this particular pairing of ICS feed and
     * Canvas calendar
     **/
    public function getId($algorithm = 'md5')
    {
        return hash($algorithm, $this->getContext()->getCanonicalUrl() . $this->getFeedUrl());
    }

    /**
     * Get the Canvas context code for this calendar
     *
     * @return string
     */
    public function getContextCode()
    {
        return $this->getContext()->getContext() . '_' . $this->getContext()->getId();
    }

    /**
     * Save this calendar to the database
     *
     * @return void
     */
    public function save()
    {
        $db = Syncable::getDatabase();
        $find = $db->prepare(
            "SELECT * FROM `calendars` WHERE `id` = :id"
        );
        $update = $db->prepare(
            "UPDATE `calendars`
                SET
                    `name` = :name,
                    `canvas_url` = :canvas_url,
                    `ics_url` = :ics_url,
                    `synced` = :synced,
                    `enable_regex_filter` = :enable_regex_filter,
                    `include_regexp` = :include_regexp,
                    `exclude_regexp` = :exclude_regexp
                WHERE
                `id` = :id"
        );
        $insert = $db->prepare(
            "INSERT INTO `calendars`
                (
                    `id`,
                    `name`,
                    `canvas_url`,
                    `ics_url`,
                    `synced`,
                    `enable_regex_filter`,
                    `include_regexp`,
                    `exclude_regexp`
                ) VALUES (
                    :id,
                    :name,
                    :canvas_url,
                    :ics_url,
                    :synced
                    :enable_regex_filter,
                    :include_regexp,
                    :exclude_regexp
                )"
        );
        $params = [
            'id' => $this->getId(),
            'name' => $this->getName(),
            'canvas_url' => $this->getContext()->getCanonicalUrl(),
            'ics_url' => $this->getFeedUrl(),
            'synced' => Syncable::getTimestamp(),
            'enable_regex_filter' => $this->getFilter()->isEnabled(),
            'include_regexp' => $this->getFilter()->getIncludeExpression(),

The method getIncludeExpression() does not seem to exist on object<smtech\CanvasICSSync\SyncIntoCanvas\Filter\Filter>.

            'exclude_regexp' => $this->getFilter()->getExcludeExpression()

The method getExcludeExpression() does not seem to exist on object<smtech\CanvasICSSync\SyncIntoCanvas\Filter\Filter>.

        ];

        $find->execute($params);
        if ($find->fetch() !== false) {
            $update->execute($params);
        } else {
            $insert->execute($params);
        }
    }

    /**
     * Load a Calendar from the database
     *
     * @param string|int $id
     * @return Calendar
     */
    public static function load($id)
    {
        $find = Syncable::getDatabase()->prepare(
            "SELECT * FROM `calendars` WHERE `id` = :id"
        );
        $find->execute($id);
        if (($calendar = $find->fetch()) !== false) {
            return new Calendar(
                $calendar['canvas_url'],
                $calendar['ics_url'],
                $calendar['enable_regex_filter'],
                $calendar['include_regexp'],
                $calendar['exclude_regexp']
            );
        }
        return null;
    }

    /**
     * Delete this calendar from the database
     *
     * @return void
     */
    public function delete()
    {
        $delete = Syncable::getDatabase()->prepare(
            "DELETE FROM `calendars` WHERE `id` = :id"
        );
        $delete->execute($this->getId());
    }

    /**
     * Sync the calendar feed into Canvas
     *
     * @param Log $log
     * @return void
     */
    public function sync(Log $log)
    {
        try {
            Syncable::getApi()->get($this->getContext()->getVerificationUrl());
        } catch (Exception $e) {
            $this->logThrow(new Exception("Cannot sync calendars without a valid Canvas context"), $log);
        }

        if (!DataUtilities::URLexists($this->getFeedUrl())) {
            $this->logThrow(new Exception("Cannot sync calendars with a valid calendar feed"), $log);
        }

        $this->log(Syncable::getTimestamp() . ' sync started', $log);

        $this->save();

        $ics = new vcalendar([
            'unique_id' => __FILE__,
            'url' => $this->getFeedUrl()
        ]);
        $ics->parse();

        /*
         * TODO: would it be worth the performance improvement to just process
         *     things from today's date forward? (i.e. ignore old items, even
         *     if they've changed...)
         */
        /*
         * TODO:0 the best window for syncing would be the term of the course
         *     in question, right? issue:12
         */
        /*
         * TODO:0 Arbitrarily selecting events in for a year on either side of
         *     today's date, probably a better system? issue:12
         */
        if (($components = $ics->selectComponents(
            date('Y') - 1, // startYear
            date('m'), // startMonth
            date('d'), // startDay
            date('Y') + 1, // endYEar
            date('m'), // endMonth
            date('d'), // endDay
            'vevent', // cType
            false, // flat
            true, // any
            true // split
        )) !== false) {
            foreach ($components as $year) {
                foreach ($year as $month => $days) {
                    foreach ($days as $day => $events) {
                        foreach ($events as $i => $_event) {
                            try {
                                $event = new Event($_event, $this);
                                $include = true;
                                foreach ($this->filters as $filter) {
                                    $include &= $filter->filter($event);
                                }
                                if ($include) {
                                    foreach ($this->transforms as $transform) {
                                        $transform->transform($event);
                                    }
                                    $event->save();
                                } else {
                                    $event->delete();
                                }
                            } catch (Exception $e) {
                                $this->logThrow($e, $log);
                            }
                        }
                    }
                }
            }
        }

        try {
            Event::purgeUnmatched(Syncable::getTimestamp(), $this);
        } catch (Exception $e) {
            $this->logThrow($e, $log);
        }

        $this->log(Syncable::getTimestamp() . ' sync finished', $log);
    }

    /**
     * Write to the log, if we have one
     *
     * @param string $message
     * @param Log $log
     * @param mixed $priority
     * @return void
     */
    private function log($message, Log $log, $priority = PEAR_LOG_INFO)
    {
        if ($log) {
            $log->log($message, $priority);
        }
    }

    /**
     * Write exception to the log, if we have one, or re-throw the exception
     *
     * @param Exception $exception
     * @param Log $log
     * @param string $priority
     * @return void
     * @throws Exception If no log is available
     */
    private function logThrow(
        Exception $exception,
        Log $log,
        $priority = PEAR_LOG_ERR
    ) {
        if ($log) {
            $log->log($exception->getMessage() . ': ' . $exception->getTraceAsString(), $priority);
        } else {
            throw $exception;
        }
    }
}