芝麻web文件管理V1.00

编辑当前文件:/home/mgatv524/public_html/avenida/views/Entity.zip

PK�������qYwV�'����
��Layout.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Xibo\Event\LayoutBuildEvent;
use Xibo\Event\LayoutBuildRegionEvent;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\CampaignFactory;
use Xibo\Factory\DataSetFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\ModuleFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\RegionFactory;
use Xibo\Factory\TagFactory;
use Xibo\Helper\Environment;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;
use Xibo\Widget\ModuleWidget;

/**
 * Class Layout
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Layout implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="The layoutId"
     * )
     * @var int
     */
    public $layoutId;

/**
     * @var int
     * @SWG\Property(
     *  description="The userId of the Layout Owner"
     * )
     */
    public $ownerId;

/**
     * @var int
     * @SWG\Property(
     *  description="The id of the Layout's dedicated Campaign"
     * )
     */
    public $campaignId;

/**
     * @var int
     * @SWG\Property(
     *  description="The parentId, if this Layout has a draft"
     * )
     */
    public $parentId;

/**
     * @var int
     * @SWG\Property(
     *  description="The Status Id"
     * )
     */
    public $publishedStatusId = 1;

/**
     * @var string
     * @SWG\Property(
     *  description="The Published Status (Published, Draft or Pending Approval"
     * )
     */
    public $publishedStatus;

/**
     * @var string
     * @SWG\Property(
     *  description="The Published Date"
     * )
     */
    public $publishedDate;

/**
     * @var int
     * @SWG\Property(
     *  description="The id of the image media set as the background"
     * )
     */
    public $backgroundImageId;

/**
     * @var int
     * @SWG\Property(
     *  description="The XLF schema version"
     * )
     */
    public $schemaVersion;

/**
     * @var string
     * @SWG\Property(
     *  description="The name of the Layout"
     * )
     */
    public $layout;

/**
     * @var string
     * @SWG\Property(
     *  description="The description of the Layout"
     * )
     */
    public $description;

/**
     * @var string
     * @SWG\Property(
     *  description="A HEX string representing the Layout background color"
     * )
     */
    public $backgroundColor;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was created"
     * )
     */
    public $createdDt;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was last modified"
     * )
     */
    public $modifiedDt;

/**
     * @var int
     * @SWG\Property(
     *  description="Flag indicating the Layout status"
     * )
     */
    public $status;

/**
     * @var int
     * @SWG\Property(
     *  description="Flag indicating whether the Layout is retired"
     * )
     */
    public $retired;

/**
     * @var int
     * @SWG\Property(
     *  description="The Layer that the background should occupy"
     * )
     */
    public $backgroundzIndex;

/**
     * @var double
     * @SWG\Property(
     *  description="The Layout Width"
     * )
     */
    public $width;

/**
     * @var double
     * @SWG\Property(
     *  description="The Layout Height"
     * )
     */
    public $height;

/**
     * @var int
     * @SWG\Property(
     *  description="If this Layout has been requested by Campaign, then this is the display order of the Layout within the Campaign"
     * )
     */
    public $displayOrder;

/**
     * @var int
     * @SWG\Property(
     *  description="A read-only estimate of this Layout's total duration in seconds. This is equal to the longest region duration and is valid when the layout status is 1 or 2."
     * )
     */
    public $duration;

/**
     * @var string
     * @SWG\Property(description="A status message detailing any errors with the layout")
     */
    public $statusMessage;

/**
     * @var int
     * @SWG\Property(
     *  description="Flag indicating whether the Layout stat is enabled"
     * )
     */
    public $enableStat;

/**
     * @var int
     * @SWG\Property(
     *  description="Flag indicating whether the default transitions should be applied to this Layout"
     * )
     */
    public $autoApplyTransitions;

// Child items
    /**
     * @SWG\Property(description="An array of Regions belonging to this Layout")
     * @var Region[]
     */
    public $regions = [];

/**
     * @SWG\Property(description="An array of Tags belonging to this Layout")
     * @var \Xibo\Entity\Tag[]
     */
    public $tags = [];
    public $permissions = [];
    public $campaigns = [];

// Read only properties
    public $owner;
    public $groupsWithPermissions;

public $tagValues;

// Private
    private $unassignTags = [];

// Handle empty regions
    private $hasEmptyRegion = false;

public static $loadOptionsMinimum = [
        'loadPlaylists' => false,
        'loadTags' => false,
        'loadPermissions' => false,
        'loadCampaigns' => false
    ];

public static $saveOptionsMinimum = [
        'saveLayout' => true,
        'saveRegions' => false,
        'saveTags' => false,
        'setBuildRequired' => true,
        'validate' => false,
        'audit' => false,
        'notify' => false
    ];

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var DateServiceInterface
     */
    private $date;

/** @var  EventDispatcherInterface */
    private $dispatcher;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var RegionFactory
     */
    private $regionFactory;

/**
     * @var TagFactory
     */
    private $tagFactory;

/**
     * @var CampaignFactory
     */
    private $campaignFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var ModuleFactory
     */
    private $moduleFactory;

/** @var PlaylistFactory */
    private $playlistFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param DateServiceInterface $date
     * @param EventDispatcherInterface $eventDispatcher
     * @param PermissionFactory $permissionFactory
     * @param RegionFactory $regionFactory
     * @param TagFactory $tagFactory
     * @param CampaignFactory $campaignFactory
     * @param LayoutFactory $layoutFactory
     * @param MediaFactory $mediaFactory
     * @param ModuleFactory $moduleFactory
     */
    public function __construct($store, $log, $config, $date, $eventDispatcher, $permissionFactory, $regionFactory, $tagFactory, $campaignFactory, $layoutFactory, $mediaFactory, $moduleFactory, $playlistFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->setPermissionsClass('Xibo\Entity\Campaign');
        $this->config = $config;
        $this->date = $date;
        $this->dispatcher = $eventDispatcher;
        $this->permissionFactory = $permissionFactory;
        $this->regionFactory = $regionFactory;
        $this->tagFactory = $tagFactory;
        $this->campaignFactory = $campaignFactory;
        $this->layoutFactory = $layoutFactory;
        $this->mediaFactory = $mediaFactory;
        $this->moduleFactory = $moduleFactory;
        $this->playlistFactory = $playlistFactory;
    }

public function __clone()
    {
        // Clear the layout id
        $this->layoutId = null;
        $this->campaignId = null;
        $this->hash = null;
        $this->permissions = [];

// A normal clone (for copy) will set this to Published, so that the copy is published.
        $this->publishedStatusId = 1;

// Clone the regions
        $this->regions = array_map(function ($object) { return clone $object; }, $this->regions);
    }

/**
     * @return string
     */
    public function __toString()
    {
        $countRegions = is_array($this->regions) ? count($this->regions) : 0;
        $countTags = is_array($this->tags) ? count($this->tags) : 0;

$statusMessages = $this->getStatusMessage();
        $countMessages = is_array($statusMessages) ? count($statusMessages) : 0;

return sprintf('Layout %s - %d x %d. Regions = %d, Tags = %d. layoutId = %d. Status = %d, messages %d', $this->layout, $this->width, $this->height, $countRegions, $countTags, $this->layoutId, $this->status, $countMessages);
    }

/**
     * @return string
     */
    private function hash()
    {
        return md5($this->layoutId . $this->ownerId . $this->campaignId . $this->backgroundImageId . $this->backgroundColor . $this->width . $this->height . $this->status . $this->description . json_encode($this->statusMessage) . $this->publishedStatusId);
    }

/**
     * Get the Id
     * @return int
     */
    public function getId()
    {
        return $this->campaignId;
    }

/**
     * Get the OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Sets the Owner of the Layout (including children)
     * @param int $ownerId
     * @param bool $cascade Cascade ownership change down to Playlist records
     */
    public function setOwner($ownerId, $cascade = false)
    {
        $this->ownerId = $ownerId;

$this->load();

foreach ($this->regions as $region) {
            /* @var Region $region */
            $region->setOwner($ownerId, $cascade);
        }
    }

/**
     * Set the status of this layout to indicate a build is required
     */
    private function setBuildRequired()
    {
        $this->status = 3;
    }

/**
     * Load Regions from a Layout
     * @param int $regionId
     * @return Region
     * @throws NotFoundException
     */
    public function getRegion($regionId)
    {
        foreach ($this->regions as $region) {
            /* @var Region $region */
            if ($region->regionId == $regionId)
                return $region;
        }

throw new NotFoundException(__('Cannot find region'));
    }

/**
     * @return bool if this Layout has an empty Region.
     */
    public function hasEmptyRegion()
    {
        return $this->hasEmptyRegion;
    }

/**
     * Get Widgets assigned to this Layout
     * @return Widget[]
     * @throws NotFoundException
     */
    public function getWidgets()
    {
        $widgets = [];

foreach ($this->regions as $region) {
            $widgets = array_merge($region->getPlaylist()->widgets, $widgets);
        }

return $widgets;
    }

/**
     * Is this Layout Editable - i.e. are we in a draft state or not.
     * @return bool true if this layout is editable
     */
    public function isEditable()
    {
        return ($this->publishedStatusId === 2); // Draft
    }

/**
     * Is this Layout a Child?
     * @return bool
     */
    public function isChild()
    {
        return ($this->parentId !== null);
    }

/**
     * @return array
     */
    public function getStatusMessage()
    {
        if ($this->statusMessage === null || empty($this->statusMessage))
            return [];

if (is_array($this->statusMessage))
            return $this->statusMessage;

$this->statusMessage = json_decode($this->statusMessage, true);

return $this->statusMessage;
    }

/**
     * Push a new message
     * @param $message
     */
    public function pushStatusMessage($message)
    {
        $this->getStatusMessage();

$this->statusMessage[] = $message;
    }

/**
     * Clear status message
     */
    private function clearStatusMessage()
    {
        $this->statusMessage = null;
    }

/**
     * Load this Layout
     * @param array $options
     * @throws XiboException
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadPlaylists' => true,
            'loadTags' => true,
            'loadPermissions' => true,
            'loadCampaigns' => true
        ], $options);

if ($this->loaded || $this->layoutId == 0)
            return;

$this->getLog()->debug('Loading Layout %d with options %s', $this->layoutId, json_encode($options));

// Load permissions
        if ($options['loadPermissions'])
            $this->permissions = $this->permissionFactory->getByObjectId('Xibo\\Entity\\Campaign', $this->campaignId);

// Load all regions
        $this->regions = $this->regionFactory->getByLayoutId($this->layoutId);

if ($options['loadPlaylists'])
            $this->loadPlaylists($options);

// Load all tags
        if ($options['loadTags'])
            $this->tags = $this->tagFactory->loadByLayoutId($this->layoutId);

// Load Campaigns
        if ($options['loadCampaigns'])
            $this->campaigns = $this->campaignFactory->getByLayoutId($this->layoutId);

// Set the hash
        $this->hash = $this->hash();
        $this->loaded = true;

$this->getLog()->debug('Loaded ' . $this->layoutId . ' with hash ' . $this->hash . ', status ' . $this->status);
    }

/**
     * Load Playlists
     * @param array $options
     * @throws XiboException
     */
    public function loadPlaylists($options = [])
    {
        foreach ($this->regions as $region) {
            /* @var Region $region */
            $region->load($options);
        }
    }

/**
     * Save this Layout
     * @param array $options
     * @throws XiboException
     */
    public function save($options = [])
    {
        // Default options
        $options = array_merge([
            'saveLayout' => true,
            'saveRegions' => true,
            'saveTags' => true,
            'setBuildRequired' => true,
            'validate' => true,
            'notify' => true,
            'audit' => true
        ], $options);

if ($options['validate'])
            $this->validate();

if ($options['setBuildRequired'])
            $this->setBuildRequired();

$this->getLog()->debug('Saving ' . $this . ' with options ' . json_encode($options, JSON_PRETTY_PRINT));

// New or existing layout
        if ($this->layoutId == null || $this->layoutId == 0) {
            $this->add();

if ($options['audit']) {
                if ($this->parentId === null) {
                    $this->audit($this->layoutId, 'Added', ['layoutId' => $this->layoutId, 'layout' => $this->layout, 'campaignId' => $this->campaignId]);
                } else {
                    $this->audit($this->layoutId, 'Checked out', ['layoutId' => $this->parentId, 'layout' => $this->layout, 'campaignId' => $this->campaignId]);
                }
            }

} else if (($this->hash() != $this->hash && $options['saveLayout']) || $options['setBuildRequired']) {
            $this->update($options);

if ($options['audit']) {
                $change = $this->getChangedProperties();
                $change['campaignId'][] = $this->campaignId;

if ($this->parentId === null) {
                    $this->audit($this->layoutId, 'Updated', $change);
                } else {
                    $this->audit($this->layoutId, 'Updated Draft', $change);
                }
            }

} else {
            $this->getLog()->info('Save layout properties unchanged for layoutId ' . $this->layoutId . ', status = ' . $this->status);
        }

if ($options['saveRegions']) {
            $this->getLog()->debug('Saving Regions on ' . $this);

// Update the regions
            foreach ($this->regions as $region) {
                /* @var Region $region */

// Assert the Layout Id
                $region->layoutId = $this->layoutId;
                $region->save($options);
            }
        }

if ($options['saveTags']) {
            $this->getLog()->debug('Saving tags on ' . $this);

// Save the tags
            if (is_array($this->tags)) {
                foreach ($this->tags as $tag) {
                    /* @var Tag $tag */

$this->getLog()->debug('Assigning tag ' . $tag->tag);

$tag->assignLayout($this->layoutId);
                    $tag->save();
                }
            }

// Remove unwanted ones
            if (is_array($this->unassignTags)) {
                foreach ($this->unassignTags as $tag) {
                    /* @var Tag $tag */
                    $this->getLog()->debug('Unassigning tag ' . $tag->tag);

$tag->unassignLayout($this->layoutId);
                    $tag->save();
                }
            }
        }

$this->getLog()->debug('Save finished for ' . $this);
    }

/**
     * Delete Layout
     * @param array $options
     * @throws XiboException
     */
    public function delete($options = [])
    {
        // We must ensure everything is loaded before we delete
        if (!$this->loaded)
            $this->load();

$this->getLog()->debug('Deleting ' . $this);

// We cannot delete the default default
        if ($this->layoutId == $this->config->getSetting('DEFAULT_LAYOUT'))
            throw new InvalidArgumentException(__('This layout is used as the global default and cannot be deleted'), 'layoutId');

// Delete our draft if we have one
        // this is recursive, so be careful!
        if ($this->parentId === null && $this->publishedStatusId === 2) {
            try {
                $draft = $this->layoutFactory->getByParentId($this->layoutId);
                $draft->delete(['notify' => false]);
            } catch (NotFoundException $notFoundException) {
                $this->getLog()->info('No draft to delete for a Layout in the Draft state, odd!');
            }
        }

// Unassign all Tags
        foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tag->unassignLayout($this->layoutId);
            $tag->save();
        }

// Delete Regions
        foreach ($this->regions as $region) {
            /* @var Region $region */
            $region->delete($options);
        }

// If we are the top level parent we also delete objects that sit on the top-level
        if ($this->parentId === null) {

// Delete Permissions
            foreach ($this->permissions as $permission) {
                /* @var Permission $permission */
                $permission->deleteAll();
            }

// Delete widget history
            $this->getStore()->update('DELETE FROM `widgethistory` WHERE layoutHistoryId IN (SELECT layoutHistoryId FROM `layouthistory` WHERE campaignId = :campaignId)', ['campaignId' => $this->campaignId]);

// Delete layout history
            $this->getStore()->update('DELETE FROM `layouthistory` WHERE campaignId = :campaignId', ['campaignId' => $this->campaignId]);

// Unassign from all Campaigns
            foreach ($this->campaigns as $campaign) {
                /* @var Campaign $campaign */
                $campaign->setChildObjectDependencies($this->layoutFactory);
                $campaign->unassignLayout($this, true);
                $campaign->save(['validate' => false]);
            }

// Delete our own Campaign
            $campaign = $this->campaignFactory->getById($this->campaignId);
            $campaign->setChildObjectDependencies($this->layoutFactory);
            $campaign->delete();

// Remove the Layout from any display defaults
            $this->getStore()->update('UPDATE `display` SET defaultlayoutid = :defaultLayoutId WHERE defaultlayoutid = :layoutId', [
                'layoutId' => $this->layoutId,
                'defaultLayoutId' => $this->config->getSetting('DEFAULT_LAYOUT')
            ]);

// Remove any display group links
            $this->getStore()->update('DELETE FROM `lklayoutdisplaygroup` WHERE layoutId = :layoutId', ['layoutId' => $this->layoutId]);

} else {
            // Remove the draft from any Campaign assignments
            $this->getStore()->update('DELETE FROM `lkcampaignlayout` WHERE layoutId = :layoutId', ['layoutId' => $this->layoutId]);
        }

// Remove the Layout (now it is orphaned it can be deleted safely)
        $this->getStore()->update('DELETE FROM `layout` WHERE layoutid = :layoutId', array('layoutId' => $this->layoutId));

$this->getLog()->audit('Layout', $this->layoutId, 'Layout Deleted', ['layoutId' => $this->layoutId]);

// Delete the cached file (if there is one)
        if (file_exists($this->getCachePath()))
            @unlink($this->getCachePath());

// Audit the Delete
        $this->audit($this->layoutId, 'Deleted' . (($this->parentId !== null) ? ' draft for ' . $this->parentId : ''));
    }

/**
     * Validate this layout
     * @throws XiboException
     */
    public function validate()
    {
        // We must provide either a template or a resolution
        if ($this->width == 0 || $this->height == 0)
            throw new InvalidArgumentException(__('The layout dimensions cannot be empty'), 'width/height');

// Validation
        if (strlen($this->layout) > 50 || strlen($this->layout) < 1)
            throw new InvalidArgumentException(__("Layout Name must be between 1 and 50 characters"), 'name');

if (strlen($this->description) > 254)
            throw new InvalidArgumentException(__("Description can not be longer than 254 characters"), 'description');

// Check for duplicates
        // exclude our own duplicate (if we're a draft)
        $duplicates = $this->layoutFactory->query(null, [
            'userId' => $this->ownerId,
            'layoutExact' => $this->layout,
            'notLayoutId' => ($this->parentId !== null) ? $this->parentId : $this->layoutId,
            'disableUserCheck' => 1,
            'excludeTemplates' => -1
        ]);

if (count($duplicates) > 0) {
            throw new DuplicateEntityException(sprintf(__("You already own a Layout called '%s'. Please choose another name."), $this->layout));
        }

// Check zindex is positive
        if ($this->backgroundzIndex < 0) {
            throw new InvalidArgumentException(__('Layer must be 0 or a positive number'), 'backgroundzIndex');
        }
    }

/**
     * Does the layout have the provided tag?
     * @param $searchTag
     * @return bool
     */
    public function hasTag($searchTag)
    {
        $this->load();

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            if ($tag->tag == $searchTag)
                return true;
        }

return false;
    }

/**
     * Assign Tag
     * @param Tag $tag
     * @return $this
     */
    public function assignTag($tag)
    {
        $this->load();

if ($this->tags != [$tag]) {

if (!in_array($tag, $this->tags)) {
                $this->tags[] = $tag;
            }
        } else {
            $this->getLog()->debug('No Tags to assign');
        }

return $this;
    }

/**
     * Add layout history
     *  this is called when a new Layout is added, and when a Draft Layout is published
     *  we can therefore expect to always have a Layout History record for a Layout
     */
    private function addLayoutHistory()
    {
        $this->getLog()->debug('Adding Layout History record for ' . $this->layoutId);

// Add a record in layout history when a layout is added or published
        $this->getStore()->insert('
          INSERT INTO `layouthistory` (campaignId, layoutId, publishedDate)
            VALUES (:campaignId, :layoutId, :publishedDate)
        ', [
            'campaignId' => $this->campaignId,
            'layoutId' => $this->layoutId,
            'publishedDate' => $this->date->parse()->format('Y-m-d H:i:s')
        ]);
    }

/**
     * Add Widget History
     *  this should be called when the contents of a Draft Layout are destroyed during the publish process
     *  it preserves the current state of widgets before they are removed from the database
     *  that can then be used for proof of play stats, to get back to the original widget name/type and mediaId
     * @param \Xibo\Entity\Layout $parent
     * @throws \Xibo\Exception\NotFoundException
     */
    private function addWidgetHistory($parent)
    {
        // Get the most recent layout history record
        $layoutHistoryId = $this->getStore()->select('
            SELECT layoutHistoryId FROM `layouthistory` WHERE layoutId = :layoutId
        ', [
            'layoutId' => $parent->layoutId
        ]);

if (count($layoutHistoryId) <= 0) {
            // We are missing the parent layout history record, which isn't good.
            // I think all we can do at this stage is log it
            $this->getLog()->alert('Missing Layout History for layoutId ' . $parent->layoutId . ' which is on campaignId ' . $parent->campaignId);
            return;
        }

$layoutHistoryId = intval($layoutHistoryId[0]['layoutHistoryId']);

// Add records in the widget history table representing all widgets on this Layout
        foreach ($parent->getWidgets() as $widget) {

// Does this widget have a mediaId
            $mediaId = null;
            try {
                $mediaId = $widget->getPrimaryMediaId();
            } catch (NotFoundException $notFoundException) {
                // this is fine
            }

$this->getStore()->insert('
                INSERT INTO `widgethistory` (layoutHistoryId, widgetId, mediaId, type, name) 
                    VALUES (:layoutHistoryId, :widgetId, :mediaId, :type, :name);
            ', [
                'layoutHistoryId' => $layoutHistoryId,
                'widgetId' => $widget->widgetId,
                'mediaId' => $mediaId,
                'type' => $widget->type,
                'name' => $widget->getOptionValue('name', null),
            ]);
        }
    }

/**
     * Unassign tag
     * @param Tag $tag
     * @return $this
     * @throws NotFoundException
     * @throws XiboException
     */
    public function unassignTag($tag)
    {
        $this->load();

$this->tags = array_udiff($this->tags, [$tag], function($a, $b) {
            /* @var Tag $a */
            /* @var Tag $b */
            return $a->tagId - $b->tagId;
        });

$this->unassignTags[] = $tag;

$this->getLog()->debug('Tags after removal %s', json_encode($this->tags));

return $this;
    }

/**
     * @param array[Tag] $tags
     */
    public function replaceTags($tags = [])
    {
        if (!is_array($this->tags) || count($this->tags) <= 0)
            $this->tags = $this->tagFactory->loadByLayoutId($this->layoutId);

if ($this->tags != $tags) {
            $this->unassignTags = array_udiff($this->tags, $tags, function ($a, $b) {
                /* @var Tag $a */
                /* @var Tag $b */
                return $a->tagId - $b->tagId;
            });

$this->getLog()->debug('Tags to be removed: %s', json_encode($this->unassignTags));

// Replace the arrays
            $this->tags = $tags;

$this->getLog()->debug('Tags remaining: %s', json_encode($this->tags));
        } else {
            $this->getLog()->debug('Tags were not changed');
        }
    }

/**
     * Export the Layout as its XLF
     * @return string
     * @throws InvalidArgumentException
     * @throws NotFoundException
     * @throws XiboException
     */
    public function toXlf()
    {
        $this->getLog()->debug('Layout toXLF for Layout ' . $this->layout . ' - ' . $this->layoutId);

$this->load(['loadPlaylists' => true]);

// Keep track of whether this layout has an empty region
        $this->hasEmptyRegion = false;
        $layoutCountRegionsWithDuration = 0;

$document = new \DOMDocument();
        $layoutNode = $document->createElement('layout');
        $layoutNode->setAttribute('width', $this->width);
        $layoutNode->setAttribute('height', $this->height);
        $layoutNode->setAttribute('bgcolor', $this->backgroundColor);
        $layoutNode->setAttribute('schemaVersion', $this->schemaVersion);

// Layout stat collection flag
        if (is_null($this->enableStat)) {
            $layoutEnableStat =  $this->config->getSetting('LAYOUT_STATS_ENABLED_DEFAULT');
            $this->getLog()->debug('Layout enableStat is empty. Get the default setting.');
        } else {
            $layoutEnableStat = $this->enableStat;
        }
        $layoutNode->setAttribute('enableStat', $layoutEnableStat);

// Only set the z-index if present
        if ($this->backgroundzIndex != 0)
            $layoutNode->setAttribute('zindex', $this->backgroundzIndex);

if ($this->backgroundImageId != 0) {
            // Get stored as
            $media = $this->mediaFactory->getById($this->backgroundImageId);

$layoutNode->setAttribute('background', $media->storedAs);
        }

$document->appendChild($layoutNode);

// Track module status within the layout
        $status = 0;
        $this->clearStatusMessage();

foreach ($this->regions as $region) {
            /* @var Region $region */
            $regionNode = $document->createElement('region');
            $regionNode->setAttribute('id', $region->regionId);
            $regionNode->setAttribute('width', $region->width);
            $regionNode->setAttribute('height', $region->height);
            $regionNode->setAttribute('top', $region->top);
            $regionNode->setAttribute('left', $region->left);

// Only set the zIndex if present
            if ($region->zIndex != 0)
                $regionNode->setAttribute('zindex', $region->zIndex);

$layoutNode->appendChild($regionNode);

// Region Duration
            $region->duration = 0;

// Region Options
            $regionOptionsNode = $document->createElement('options');

foreach ($region->regionOptions as $regionOption) {
                $regionOptionNode = $document->createElement($regionOption->option, $regionOption->value);
                $regionOptionsNode->appendChild($regionOptionNode);
            }

$regionNode->appendChild($regionOptionsNode);

// Store region look to work out duration calc
            $regionLoop = $region->getOptionValue('loop', 0);

// Get a count of widgets in this region
            $widgets = $region->getPlaylist()->setModuleFactory($this->moduleFactory)->expandWidgets();
            $countWidgets = count($widgets);

if ($countWidgets <= 0) {
                $this->getLog()->info('Layout has empty region - ' . $countWidgets . ' widgets. playlistId = ' . $region->getPlaylist()->getId());
                $this->hasEmptyRegion = true;
            }

// Work out if we have any "lead regions", those are Widgets with a duration
            foreach ($widgets as $widget) {
                if ($widget->useDuration == 1 || $countWidgets > 1 || $regionLoop == 1 || $widget->type == 'video') {
                    $layoutCountRegionsWithDuration++;
                }
            }

foreach ($widgets as $widget) {
                /* @var Widget $widget */
                $module = $this->moduleFactory->createWithWidget($widget, $region);

// Set the Layout Status
                try {
                    $moduleStatus = $module->isValid();
                    if ($module->hasStatusMessage()) {
                        $this->pushStatusMessage($module->getStatusMessage());
                    }
                } catch (XiboException $xiboException) {
                    $moduleStatus = ModuleWidget::$STATUS_INVALID;

// Include the exception on
                    $this->pushStatusMessage($xiboException->getMessage());
                }

$status = ($moduleStatus > $status) ? $moduleStatus : $status;

// Determine the duration of this widget
                // the calculated duration contains the best guess at this duration from the playlist's perspective
                // the only time we want to override this, is if we want it set to the Minimum Duration for the XLF
                $widgetDuration = $widget->calculatedDuration;

// Is this Widget one that does not have a duration of its own?
                // Assuming we have at least 1 region with a set duration, then we ought to
                // Reset to the minimum duration
                if ($widget->useDuration == 0 && $countWidgets <= 1 && $regionLoop == 0 && $widget->type != 'video'
                    && $layoutCountRegionsWithDuration >= 1
                ) {
                    // Make sure this Widget expires immediately so that the other Regions can be the leaders when
                    // it comes to expiring the Layout
                    $widgetDuration = Widget::$widgetMinDuration;
                }

// Region duration
                $region->duration = $region->duration + $widget->calculatedDuration;

// We also want to add any transition OUT duration
                // only the OUT duration because IN durations do not get added to the widget duration by the player
                // https://github.com/xibosignage/xibo/issues/705
                if ($widget->getOptionValue('transOut', '') != '') {
                    // Transition durations are in milliseconds
                    $region->duration = $region->duration + ($widget->getOptionValue('transOutDuration', 0) / 1000);
                }

// Create media xml node for XLF.
                $renderAs = $module->getModule()->renderAs;
                $mediaNode = $document->createElement('media');
                $mediaNode->setAttribute('id', $widget->widgetId);
                $mediaNode->setAttribute('type', $widget->type);
                $mediaNode->setAttribute('render', ($renderAs == '') ? 'native' : $renderAs);

// Set the duration according to whether we are using widget duration or not
                $mediaNode->setAttribute('duration', $widgetDuration);
                $mediaNode->setAttribute('useDuration', $widget->useDuration);

// Set a from/to date
                if ($widget->fromDt != null || $widget->fromDt === Widget::$DATE_MIN) {
                    $mediaNode->setAttribute('fromDt', $this->date->getLocalDate($this->date->parse($widget->fromDt, 'U')));
                }

if ($widget->toDt != null || $widget->toDt === Widget::$DATE_MAX) {
                    $mediaNode->setAttribute('toDt', $this->date->getLocalDate($this->date->parse($widget->toDt, 'U')));
                }

//                Logic Table
//
//                Widget With Media
//                LAYOUT	MEDIA	WIDGET	Media stats collected?
//                    ON	ON	    ON	    YES     Widget takes precedence     // Match - 1
//                    ON	OFF	    ON	    YES     Widget takes precedence     // Match - 1
//                    ON	INHERIT	ON	    YES     Widget takes precedence     // Match - 1
//
//                    OFF	ON	    ON	    YES     Widget takes precedence     // Match - 1
//                    OFF	OFF	    ON	    YES     Widget takes precedence     // Match - 1
//                    OFF	INHERIT	ON	    YES     Widget takes precedence     // Match - 1
//
//                    ON	ON	    OFF	    NO      Widget takes precedence     // Match - 2
//                    ON	OFF	    OFF	    NO      Widget takes precedence     // Match - 2
//                    ON	INHERIT	OFF	    NO      Widget takes precedence     // Match - 2
//
//                    OFF	ON	    OFF	    NO      Widget takes precedence     // Match - 2
//                    OFF	OFF	    OFF	    NO      Widget takes precedence     // Match - 2
//                    OFF	INHERIT	OFF	    NO      Widget takes precedence     // Match - 2
//
//                    ON	ON	    INHERIT	YES     Media takes precedence      // Match - 3
//                    ON	OFF	    INHERIT	NO      Media takes precedence      // Match - 4
//                    ON	INHERIT	INHERIT	YES     Media takes precedence and Inherited from Layout        // Match - 5
//
//                    OFF	ON	    INHERIT	YES     Media takes precedence      // Match - 3
//                    OFF	OFF	    INHERIT	NO      Media takes precedence      // Match - 4
//                    OFF	INHERIT	INHERIT	NO      Media takes precedence and Inherited from Layout        // Match - 6
//
//                Widget Without Media
//                LAYOUT	WIDGET		Widget stats collected?
//                    ON	ON		    YES	    Widget takes precedence     // Match - 1
//                    ON	OFF		    NO	    Widget takes precedence     // Match - 2
//                    ON	INHERIT		YES	    Inherited from Layout       // Match - 7
//                    OFF	ON		    YES	    Widget takes precedence     // Match - 1
//                    OFF	OFF		    NO	    Widget takes precedence     // Match - 2
//                    OFF	INHERIT		NO	    Inherited from Layout       // Match - 8

// Widget stat collection flag
                $widgetEnableStat = $widget->getOptionValue('enableStat', $this->config->getSetting('WIDGET_STATS_ENABLED_DEFAULT'));

if(($widgetEnableStat === null) || ($widgetEnableStat === "")) {
                    $widgetEnableStat = $this->config->getSetting('WIDGET_STATS_ENABLED_DEFAULT');
                }

$enableStat = 0; // Match - 0

if ($widgetEnableStat == 'On') {
                    $enableStat = 1; // Match - 1
                    $this->getLog()->debug('For '.$widget->widgetId.': Layout '. (($layoutEnableStat == 1) ? 'On': 'Off') . ' Widget '.$widgetEnableStat . '. Media node output '. $enableStat);
                } else if ($widgetEnableStat == 'Off') {
                    $enableStat = 0; // Match - 2
                    $this->getLog()->debug('For '.$widget->widgetId.': Layout '. (($layoutEnableStat == 1) ? 'On': 'Off') . ' Widget '.$widgetEnableStat . '. Media node output '. $enableStat);
                } else if ($widgetEnableStat == 'Inherit') {

try {
                        // Media enable stat flag - WIDGET WITH MEDIA
                        $media = $this->mediaFactory->getById($widget->getPrimaryMediaId());

if (($media->enableStat === null) || ($media->enableStat === "")) {
                            $mediaEnableStat = $this->config->getSetting('MEDIA_STATS_ENABLED_DEFAULT');
                            $this->getLog()->debug('Media enableStat is empty. Get the default setting.');
                        } else {
                            $mediaEnableStat = $media->enableStat;
                        }

if ($mediaEnableStat == 'On') {
                            $enableStat = 1; // Match - 3
                        } else if ($mediaEnableStat == 'Off') {
                            $enableStat = 0; // Match - 4
                        } else if ($mediaEnableStat == 'Inherit') {
                            $enableStat = $layoutEnableStat;  // Match - 5 and 6
                        }

$this->getLog()->debug('For '.$widget->widgetId.': Layout '. (($layoutEnableStat == 1) ? 'On': 'Off') . ((isset($mediaEnableStat)) ? (' Media '.$mediaEnableStat) : '') . ' Widget '.$widgetEnableStat . '. Media node output '. $enableStat);

} catch (\Exception $e) { //  - WIDGET WITHOUT MEDIA
                        $this->getLog()->debug($widget->widgetId. ' is not a library media and does not have a media id.');
                        $enableStat = $layoutEnableStat;  // Match - 7 and 8

$this->getLog()->debug('For '.$widget->widgetId.': Layout '. (($layoutEnableStat == 1) ? 'On': 'Off') . ' Widget '.$widgetEnableStat . '. Media node output '. $enableStat);
                    }
                }

// automatically set the transitions on the layout xml, we are not saving widgets here to avoid deadlock issues.
                if ($this->autoApplyTransitions == 1) {
                    $widgetTransIn = $widget->getOptionValue('transIn', $this->config->getSetting('DEFAULT_TRANSITION_IN'));
                    $widgetTransOut = $widget->getOptionValue('transOut', $this->config->getSetting('DEFAULT_TRANSITION_OUT'));
                    $widgetTransInDuration = $widget->getOptionValue('transInDuration', $this->config->getSetting('DEFAULT_TRANSITION_DURATION'));
                    $widgetTransOutDuration = $widget->getOptionValue('transOutDuration', $this->config->getSetting('DEFAULT_TRANSITION_DURATION'));

$widget->setOptionValue('transIn', 'attrib', $widgetTransIn);
                    $widget->setOptionValue('transInDuration', 'attrib', $widgetTransInDuration);
                    $widget->setOptionValue('transOut', 'attrib', $widgetTransOut);
                    $widget->setOptionValue('transOutDuration', 'attrib', $widgetTransOutDuration);
                }

// Set enable stat collection flag
                $mediaNode->setAttribute('enableStat', $enableStat);

// Create options nodes
                $optionsNode = $document->createElement('options');
                $rawNode = $document->createElement('raw');

$mediaNode->appendChild($optionsNode);
                $mediaNode->appendChild($rawNode);

// Inject the URI
                $uriInjected = false;
                if ($module->getModule()->regionSpecific == 0) {
                    $media = $this->mediaFactory->getById($widget->getPrimaryMediaId());
                    $optionNode = $document->createElement('uri', $media->storedAs);
                    $optionsNode->appendChild($optionNode);
                    $uriInjected = true;

// Add the fileId attribute to the media element
                    $mediaNode->setAttribute('fileId', $media->mediaId);
                }

// Tracker whether or not we have an updateInterval configured.
                $hasUpdatedInterval = false;

foreach ($widget->widgetOptions as $option) {

if (trim($option->value) === '')
                        continue;

if ($option->type == 'cdata') {
                        $optionNode = $document->createElement($option->option);
                        $cdata = $document->createCDATASection($option->value);
                        $optionNode->appendChild($cdata);
                        $rawNode->appendChild($optionNode);
                    }
                    else if ($option->type == 'attrib' || $option->type == 'attribute') {

if ($uriInjected && $option->option == 'uri')
                            continue;

$optionNode = $document->createElement($option->option, $option->value);
                        $optionsNode->appendChild($optionNode);
                    }

if ($option->option === 'updateInterval') {
                        $hasUpdatedInterval = true;
                    }
                }

// If we do not have an update interval, should we set a default one?
                // https://github.com/xibosignage/xibo/issues/2319
                if (!$hasUpdatedInterval && $module->getModule()->regionSpecific == 1) {
                    // For the moment we will assume that all update intervals are the same as the cache duration
                    // remembering that the cache duration is in seconds and the updateInterval in minutes.
                    $optionsNode->appendChild(
                        $document->createElement('updateInterval', $module->getCacheDuration() / 60)
                    );
                }

// Handle associated audio
                $audioNodes = null;
                foreach ($widget->audio as $audio) {
                    /** @var WidgetAudio $audio */
                    if ($audioNodes == null)
                        $audioNodes = $document->createElement('audio');

// Get the full media node for this audio element
                    $audioMedia = $this->mediaFactory->getById($audio->mediaId);

$audioNode = $document->createElement('uri', $audioMedia->storedAs);
                    $audioNode->setAttribute('volume', $audio->volume);
                    $audioNode->setAttribute('loop', $audio->loop);
                    $audioNode->setAttribute('mediaId', $audio->mediaId);
                    $audioNodes->appendChild($audioNode);
                }

if ($audioNodes != null)
                    $mediaNode->appendChild($audioNodes);

$regionNode->appendChild($mediaNode);
            }

$this->getLog()->debug('Region duration on layout ' . $this->layoutId . ' is ' . $region->duration . '. Comparing to ' . $this->duration);

// Track the max duration within the layout
            // Test this duration against the layout duration
            if ($this->duration < $region->duration)
                $this->duration = $region->duration;

$event = new LayoutBuildRegionEvent($region->regionId, $regionNode);
            $this->dispatcher->dispatch($event::NAME, $event);
            // End of region loop.
        }

$this->getLog()->debug('Setting Layout Duration to ' . $this->duration);

$tagsNode = $document->createElement('tags');

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tagNode = $document->createElement('tag', $tag->tag);
            $tagsNode->appendChild($tagNode);
        }

$layoutNode->appendChild($tagsNode);

// Update the layout status / duration accordingly
        $this->status = ($status < $this->status) ? $status : $this->status;

// Fire a layout.build event, passing the layout and the generated document.
        $event = new LayoutBuildEvent($this, $document);
        $this->dispatcher->dispatch($event::NAME, $event);

return $document->saveXML();
    }

/**
     * Export the Layout as a ZipArchive
     * @param DataSetFactory $dataSetFactory
     * @param string $fileName
     * @param array $options
     * @throws InvalidArgumentException
     * @throws XiboException
     */
    public function toZip($dataSetFactory, $fileName, $options = [])
    {
        $options = array_merge([
            'includeData' => false
        ], $options);

// Load the complete layout
        $this->load();

// We export to a ZIP file
        $zip = new \ZipArchive();
        $result = $zip->open($fileName, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
        if ($result !== true)
            throw new InvalidArgumentException(__('Can\'t create ZIP. Error Code: ' . $result), 'fileName');

// Add a mapping file for the region names
        $regionMapping = [];
        foreach ($this->regions as $region) {
            /** @var Region $region */
            $regionMapping[$region->regionId] = $region->name;
        }

// Add layout information to the ZIP
        $zip->addFromString('layout.json', json_encode([
            'layout' => $this->layout,
            'description' => $this->description,
            'regions' => $regionMapping,
            'layoutDefinitions' => $this
        ]));

// Add the layout XLF
        $zip->addFile($this->xlfToDisk(), 'layout.xml');

// Add all media
        $libraryLocation = $this->config->getSetting('LIBRARY_LOCATION');
        $mappings = [];

foreach ($this->mediaFactory->getByLayoutId($this->layoutId, 1) as $media) {
            /* @var Media $media */
            $zip->addFile($libraryLocation . $media->storedAs, 'library/' . $media->fileName);

$mappings[] = [
                'file' => $media->fileName,
                'mediaid' => $media->mediaId,
                'name' => $media->name,
                'type' => $media->mediaType,
                'duration' => $media->duration,
                'background' => 0,
                'font' => 0
            ];
        }

// Add the background image
        if ($this->backgroundImageId != 0) {
            $media = $this->mediaFactory->getById($this->backgroundImageId);
            $zip->addFile($libraryLocation . $media->storedAs, 'library/' . $media->fileName);

$mappings[] = [
                'file' => $media->fileName,
                'mediaid' => $media->mediaId,
                'name' => $media->name,
                'type' => $media->mediaType,
                'duration' => $media->duration,
                'background' => 1,
                'font' => 0
            ];
        }

// Add any fonts
        //  parse the XLF file for any font declarations contains therein
        //  get those font media files by name and add them to the zip
        $fonts = null;
        preg_match_all('/font-family:(.*?);/', $this->toXlf(), $fonts);

if ($fonts != null) {

$this->getLog()->debug('Matched fonts: %s', json_encode($fonts));

foreach ($fonts[1] as $font) {
                $matches = $this->mediaFactory->query(null, array('disableUserCheck' => 1, 'nameExact' => $font, 'allModules' => 1, 'type' => 'font'));

if (count($matches) <= 0) {
                    $this->getLog()->info('Unmatched font during export: %s', $font);
                    continue;
                }

$media = $matches[0];

$zip->addFile($libraryLocation . $media->storedAs, 'library/' . $media->fileName);

$mappings[] = [
                    'file' => $media->fileName,
                    'mediaid' => $media->mediaId,
                    'name' => $media->name,
                    'type' => $media->mediaType,
                    'duration' => $media->duration,
                    'background' => 0,
                    'font' => 1
                ];
            }
        }

// Add the mappings file to the ZIP
        $zip->addFromString('mapping.json', json_encode($mappings));

// Handle any DataSet structures
        $dataSetIds = [];
        $dataSets = [];

// Playlists
        $playlistMappings = [];
        $playlistDefinitions = [];
        $nestedPlaylistDefinitions = [];

foreach ($this->getWidgets() as $widget) {
            /** @var Widget $widget */
            if ($widget->type == 'datasetview' || $widget->type == 'datasetticker' || $widget->type == 'chart') {
                $dataSetId = $widget->getOptionValue('dataSetId', 0);

if ($dataSetId != 0) {

if (in_array($dataSetId, $dataSetIds))
                        continue;

// Export the structure for this dataSet
                    $dataSet = $dataSetFactory->getById($dataSetId);
                    $dataSet->load();

// Are we also looking to export the data?
                    if ($options['includeData']) {
                        $dataSet->data = $dataSet->getData([], ['includeFormulaColumns' => false]);
                    }

$dataSetIds[] = $dataSet->dataSetId;
                    $dataSets[] = $dataSet;
                }
            }   elseif ($widget->type == 'subplaylist') {
                $playlistIds = json_decode($widget->getOptionValue('subPlaylistIds', []), true);

foreach ($playlistIds as $playlistId) {
                    $count = 1;
                    $playlist = $this->playlistFactory->getById($playlistId);
                    $playlist->load();
                    $playlist->expandWidgets(0, false);
                    $playlistDefinitions[$playlist->playlistId] = $playlist;

// this is a recursive function, we are adding Playlist definitions, Playlist mappings and DataSets existing on the nested Playlist.
                    $playlist->generatePlaylistMapping($playlist->widgets, $playlist->playlistId,$playlistMappings, $count, $nestedPlaylistDefinitions, $dataSetIds, $dataSets, $dataSetFactory, $options['includeData']);
                }
            }
        }

// Add the mappings file to the ZIP
        if ($dataSets != []) {
            $zip->addFromString('dataSet.json', json_encode($dataSets, JSON_PRETTY_PRINT));
        }

// Add the Playlist definitions to the ZIP
        if ($playlistDefinitions != []) {
            $zip->addFromString('playlist.json', json_encode($playlistDefinitions, JSON_PRETTY_PRINT));
        }

// Add the nested Playlist definitions to the ZIP
        if ($nestedPlaylistDefinitions != []) {
            $zip->addFromString('nestedPlaylist.json', json_encode($nestedPlaylistDefinitions, JSON_PRETTY_PRINT));
        }

// Add Playlist mappings file to the ZIP
        if ($playlistMappings != []) {
            $zip->addFromString('playlistMappings.json', json_encode($playlistMappings, JSON_PRETTY_PRINT));
        }

$zip->close();
    }

/**
     * Save the XLF to disk if necessary
     * @param array $options
     * @return string the path
     * @throws InvalidArgumentException
     * @throws NotFoundException
     * @throws XiboException
     */
    public function xlfToDisk($options = [])
    {
        $options = array_merge([
            'notify' => true,
            'collectNow' => true,
            'exceptionOnError' => false,
            'exceptionOnEmptyRegion' => true
        ], $options);

$path = $this->getCachePath();

if ($this->status == 3 || !file_exists($path)) {

$this->getLog()->debug('XLF needs building for Layout ' . $this->layoutId);

$this->load(['loadPlaylists' => true]);

// Layout auto Publish
            if ($this->config->getSetting('DEFAULT_LAYOUT_AUTO_PUBLISH_CHECKB') == 1 && $this->isChild()) {

// we are editing a draft layout, the published date is set on the original layout, therefore we need our parent.
                $parent = $this->layoutFactory->loadById($this->parentId);

$layoutCurrentPublishedDate = $this->date->parse($parent->publishedDate);
                $newPublishDateString = $this->date->getLocalDate($this->date->parse()->addMinutes(30), 'Y-m-d H:i:s');
                $newPublishDate = $this->date->parse($newPublishDateString);

if ($layoutCurrentPublishedDate->format('U') > $newPublishDate->format('U')) {
                    // Layout is set to Publish manually on a date further than 30 min from now, we don't touch it in this case.
                    $this->getLog()->debug('Layout is set to Publish manually on a date further than 30 min from now, do not update');

}  elseif ($parent->publishedDate != null &&  $layoutCurrentPublishedDate->format('U') < $this->date->getLocalDate($this->date->parse()->subMinutes(5), 'U')) {
                    // Layout is set to Publish manually at least 5 min in the past at the moment, we expect the Regular Maintenance to build it before that happens
                    $this->getLog()->debug('Layout should be built by Regular Maintenance');

} else {
                    $parent->setPublishedDate($newPublishDateString);
                    $this->getLog()->debug('Layout set to automatically Publish on ' . $newPublishDateString);
                }
            }

// Assume error
            $this->status = ModuleWidget::$STATUS_INVALID;

// Reset duration
            $this->duration = 0;

// Save the resulting XLF
            try {
                file_put_contents($path, $this->toXlf());
            } catch (\Exception $e) {
                $this->getLog()->error('Cannot build Layout ' . $this->layoutId . '. error: ' . $e->getMessage());

// Will continue and save the status as 4
                $this->status = ModuleWidget::$STATUS_INVALID;

if ($e->getMessage() != '') {
                    $this->pushStatusMessage($e->getMessage());
                } else {
                    $this->pushStatusMessage('Unexpected Error');
                }
                // No need to notify on an errored build
                $options['notify'] = false;
            }

if ($options['exceptionOnError']) {
                // Handle exception cases
                if ($this->status === ModuleWidget::$STATUS_INVALID
                    || ($options['exceptionOnEmptyRegion'] && $this->hasEmptyRegion())
                ) {
                    $this->audit($this->layoutId, 'Publish layout failed, rollback', ['layoutId' => $this->layoutId]);
                    throw new InvalidArgumentException(__('There is an error with this Layout: %s',
                        implode(',', $this->getStatusMessage())), 'status');
                }
            }

// If we have an empty region and we've not exceptioned, then we need to record that in our status
            if ($this->hasEmptyRegion()) {
                $this->status = ModuleWidget::$STATUS_INVALID;
                $this->pushStatusMessage(__('Empty Region'));
            }

$this->save([
                'saveRegions' => true,
                'saveRegionOptions' => false,
                'manageRegionAssignments' => false,
                'saveTags' => false,
                'setBuildRequired' => false,
                'audit' => false,
                'validate' => false,
                'notify' => $options['notify'],
                'collectNow' => $options['collectNow']
            ]);
        }

return $path;
    }

/**
     * @return string
     */
    private function getCachePath()
    {
        $libraryLocation = $this->config->getSetting('LIBRARY_LOCATION');
        return $libraryLocation . $this->layoutId . '.xlf';
    }

/**
     * Publish the Draft
     * @throws XiboException
     */
    public function publishDraft()
    {
        // We are the draft - make sure we have a parent
        if (!$this->isChild())
            throw new InvalidArgumentException(__('Not a Draft'), 'statusId');

// Get my parent for later
        $parent = $this->layoutFactory->loadById($this->parentId);

// I am the draft, so I clear my parentId, and set the parentId of my parent, to myself (swapping us)
        // Make me the parent.
        $this->getStore()->update('UPDATE `layout` SET parentId = NULL WHERE layoutId = :layoutId', [
            'layoutId' => $this->layoutId
        ]);

// Set my parent, to be my child.
        $this->getStore()->update('UPDATE `layout` SET parentId = :parentId WHERE layoutId = :layoutId', [
            'parentId' => $this->layoutId,
            'layoutId' => $this->parentId
        ]);

// clear publishedDate
        $this->getStore()->update('UPDATE `layout` SET publishedDate = null WHERE layoutId = :layoutId', [
            'layoutId' => $this->layoutId
        ]);

// Update any campaign links
        $this->getStore()->update('
          UPDATE `lkcampaignlayout` 
            SET layoutId = :layoutId 
           WHERE layoutId = :parentId 
            AND campaignId IN (SELECT campaignId FROM campaign WHERE isLayoutSpecific = 0)
        ', [
            'parentId' => $this->parentId,
            'layoutId' => $this->layoutId
        ]);

// Persist things that might have changed
        // NOTE: permissions are managed on the campaign, so we do not need to worry.
        $this->layout = $parent->layout;
        $this->description = $parent->description;
        $this->retired = $parent->retired;
        $this->enableStat = $parent->enableStat;

// Swap all tags over, any changes we've made to the parents tags should be moved to the child.
        $this->getStore()->update('UPDATE `lktaglayout` SET layoutId = :layoutId WHERE layoutId = :parentId', [
            'parentId' => $parent->layoutId,
            'layoutId' => $this->layoutId
        ]);

// Update any Displays which use this as their default Layout
        $this->getStore()->update('UPDATE `display` SET defaultLayoutId = :layoutId WHERE defaultLayoutId = :parentId', [
            'parentId' => $parent->layoutId,
            'layoutId' => $this->layoutId
        ]);

// Swap any display group links
        $this->getStore()->update('UPDATE `lklayoutdisplaygroup` SET layoutId = :layoutId WHERE layoutId = :parentId', [
            'layoutId' => $this->layoutId,
            'parentId' => $parent->layoutId
        ]);

// If this is the global default layout, then add some special handling to make sure we swap the default over
        // to the incoming draft
        if ($this->parentId == $this->config->getSetting('DEFAULT_LAYOUT')) {
            // Change it over to me.
            $this->config->changeSetting('DEFAULT_LAYOUT', $this->layoutId);
        }

// Preserve the widget information
        $this->addWidgetHistory($parent);

// Delete the parent (make sure we set the parent to be a child of us, otherwise we will delete the linked
        // campaign
        $parent->parentId = $this->layoutId;
        $parent->tags = []; // Clear the tags so we don't attempt a delete.
        $parent->permissions = []; // Clear the permissions so we don't attempt a delete
        $parent->delete();

// Set my statusId to published
        // we do not want to notify here as we should wait for the build to happen
        $this->publishedStatusId = 1;
        $this->save([
            'saveLayout' => true,
            'saveRegions' => false,
            'saveTags' => false,
            'setBuildRequired' => true,
            'validate' => false,
            'audit' => true,
            'notify' => false
        ]);

// Nullify my parentId (I no longer have a parent)
        $this->parentId = null;

// Add a layout history
        $this->addLayoutHistory();

}

public function setPublishedDate($publishedDate)
    {
        $this->publishedDate = $publishedDate;

$this->getStore()->update('UPDATE `layout` SET publishedDate = :publishedDate WHERE layoutId = :layoutId', [
            'layoutId' => $this->layoutId,
            'publishedDate' => $this->publishedDate
        ]);
    }

/**
     * Discard the Draft
     * @throws XiboException
     */
    public function discardDraft()
    {
        // We are the draft - make sure we have a parent
        if (!$this->isChild()) {
            $this->getLog()->debug('Cant discard draft ' . $this->layoutId . '. publishedStatusId = ' . $this->publishedStatusId . ', parentId = ' . $this->parentId);
            throw new InvalidArgumentException(__('Not a Draft'), 'statusId');
        }

// We just need to delete ourselves really
        $this->delete();

// We also need to update the parent so that it is no longer draft
        $parent = $this->layoutFactory->getById($this->parentId);
        $parent->publishedStatusId = 1;
        $parent->save([
            self::$saveOptionsMinimum
        ]);
    }

//
    // Add / Update
    //

/**
     * Add
     * @throws XiboException
     */
    private function add()
    {
        $this->getLog()->debug('Adding Layout' . $this->layout);

$sql  = 'INSERT INTO layout (layout, description, userID, createdDT, modifiedDT, publishedStatusId, status, width, height, schemaVersion, backgroundImageId, backgroundColor, backgroundzIndex, parentId, enableStat, duration, autoApplyTransitions)
                  VALUES (:layout, :description, :userid, :createddt, :modifieddt, :publishedStatusId, :status, :width, :height, :schemaVersion, :backgroundImageId, :backgroundColor, :backgroundzIndex, :parentId, :enableStat, 0, :autoApplyTransitions)';

$time = $this->date->getLocalDate();

$this->layoutId = $this->getStore()->insert($sql, array(
            'layout' => $this->layout,
            'description' => $this->description,
            'userid' => $this->ownerId,
            'createddt' => $time,
            'modifieddt' => $time,
            'publishedStatusId' => $this->publishedStatusId, // Default to 1 (published)
            'status' => 3,
            'width' => $this->width,
            'height' => $this->height,
            'schemaVersion' => Environment::$XLF_VERSION,
            'backgroundImageId' => $this->backgroundImageId,
            'backgroundColor' => $this->backgroundColor,
            'backgroundzIndex' => $this->backgroundzIndex,
            'parentId' => ($this->parentId == null) ? null : $this->parentId,
            'enableStat' => $this->enableStat,
            'autoApplyTransitions' => ($this->autoApplyTransitions == null) ? 0 : $this->autoApplyTransitions
        ));

// Add a Campaign
        // we do not add a campaign record for draft layouts.
        if ($this->parentId === null) {

$campaign = $this->campaignFactory->createEmpty();
            $campaign->campaign = $this->layout;
            $campaign->isLayoutSpecific = 1;
            $campaign->ownerId = $this->getOwnerId();
            $campaign->assignLayout($this);

// Ready to save the Campaign
            // adding a Layout Specific Campaign shouldn't ever notify (it can't hit anything because we've only
            // just added it)
            $campaign->save([
                'notify' => false
            ]);

// Assign the new campaignId to this layout
            $this->campaignId = $campaign->campaignId;

// Add a layout history
            $this->addLayoutHistory();

} else if ($this->campaignId == null) {
            throw new InvalidArgumentException(__('Draft Layouts must have a parent'), 'campaignId');
        } else {

// Add this draft layout as a link to the campaign
            $campaign = $this->campaignFactory->getById($this->campaignId);
            $campaign->setChildObjectDependencies($this->layoutFactory);
            $campaign->assignLayout($this);
            $campaign->save([
                'notify' => false
            ]);
        }
    }

/**
     * Update
     * @param array $options
     * @throws XiboException
     */
    private function update($options = [])
    {
        $options = array_merge([
            'notify' => true,
            'collectNow' => true
        ], $options);

$this->getLog()->debug('Editing Layout ' . $this->layout . '. Id = ' . $this->layoutId);

$sql = '
        UPDATE layout
          SET layout = :layout,
              description = :description,
              duration = :duration,
              modifiedDT = :modifieddt,
              retired = :retired,
              width = :width,
              height = :height,
              backgroundImageId = :backgroundImageId,
              backgroundColor = :backgroundColor,
              backgroundzIndex = :backgroundzIndex,
              `status` = :status,
              publishedStatusId = :publishedStatusId,
              `userId` = :userId,
              `schemaVersion` = :schemaVersion,
              `statusMessage` = :statusMessage,
              enableStat = :enableStat,
              autoApplyTransitions = :autoApplyTransitions
         WHERE layoutID = :layoutid
        ';

$time = $this->date->getLocalDate();

$this->getStore()->update($sql, array(
            'layoutid' => $this->layoutId,
            'layout' => $this->layout,
            'description' => $this->description,
            'duration' => $this->duration,
            'modifieddt' => $time,
            'retired' => $this->retired,
            'width' => $this->width,
            'height' => $this->height,
            'backgroundImageId' => ($this->backgroundImageId == null) ? null : $this->backgroundImageId,
            'backgroundColor' => $this->backgroundColor,
            'backgroundzIndex' => $this->backgroundzIndex,
            'status' => $this->status,
            'publishedStatusId' => $this->publishedStatusId,
            'userId' => $this->ownerId,
            'schemaVersion' => $this->schemaVersion,
            'statusMessage' => (empty($this->statusMessage)) ? null : json_encode($this->statusMessage),
            'enableStat' => $this->enableStat,
            'autoApplyTransitions' => $this->autoApplyTransitions
        ));

// Update the Campaign
        if ($this->parentId === null) {
            $campaign = $this->campaignFactory->getById($this->campaignId);
            $campaign->campaign = $this->layout;
            $campaign->ownerId = $this->ownerId;
            $campaign->save(['validate' => false, 'notify' => $options['notify'], 'collectNow' => $options['collectNow']]);
        }
    }

/**
     * Handle the Playlist closure table for specified Layout object
     *
     * @param $layout
     * @throws InvalidArgumentException
     */
    public function managePlaylistClosureTable($layout)
    {

// we only need to set the closure table records for the playlists assigned directly to the regionPlaylist here
        // all other relations between Playlists themselves are handled on import before layout is created
        // as the SQL we run here is recursive everything will end up with correct parent/child relation and depth level.
        foreach ($layout->getWidgets() as $widget) {
            if ($widget->type == 'subplaylist') {
                $assignedPlaylists = json_decode($widget->getOptionValue('subPlaylistIds', '[]'));
                $assignedPlaylists = implode(',', $assignedPlaylists);

foreach ($layout->regions as $region) {
                    $regionPlaylist = $region->regionPlaylist;

if ($widget->playlistId == $regionPlaylist->playlistId) {
                        $parentId = $regionPlaylist->playlistId;
                        $child[] = $assignedPlaylists;
                    }
                }
            }
        }

if (isset($parentId) && isset($child)) {
            foreach ($child as $childId) {

$this->getLog()->debug('Manage closure table for parent ' . $parentId . ' and child ' . $childId);

if ($this->getStore()->exists('SELECT parentId, childId, depth FROM lkplaylistplaylist WHERE childId = :childId AND parentId = :parentId ', [
                    'parentId' => $parentId,
                    'childId' => $childId
                ])) {
                    throw new InvalidArgumentException(__('Cannot add the same SubPlaylist twice.'), 'playlistId');
                }

$this->getStore()->insert('
                        INSERT INTO `lkplaylistplaylist` (parentId, childId, depth)
                        SELECT p.parentId, c.childId, p.depth + c.depth + 1
                          FROM lkplaylistplaylist p, lkplaylistplaylist c
                         WHERE p.childId = :parentId AND c.parentId = :childId
                    ', [
                    'parentId' => $parentId,
                    'childId' => $childId
                ]);
            }
        }
    }
}PK�������qYS��T6%��6%��
��UserGroup.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (UserGroup.php)
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Factory\UserFactory;
use Xibo\Factory\UserGroupFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class UserGroup
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class UserGroup
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Group ID")
     * @var int
     */
    public $groupId;

/**
     * @SWG\Property(description="The group name")
     * @var string
     */
    public $group;

/**
     * @SWG\Property(description="A flag indicating whether this is a user specific group or not")
     * @var int
     */
    public $isUserSpecific = 0;

/**
     * @SWG\Property(description="A flag indicating the special everyone group")
     * @var int
     */
    public $isEveryone = 0;

/**
     * @SWG\Property(description="This users library quota in bytes. 0 = unlimited")
     * @var int
     */
    public $libraryQuota;

/**
     * @SWG\Property(description="Does this Group receive system notifications.")
     * @var int
     */
    public $isSystemNotification = 0;

/**
     * @SWG\Property(description="Does this Group receive display notifications.")
     * @var int
     */
    public $isDisplayNotification = 0;

// Users
    private $users = [];

/**
     * @var UserGroupFactory
     */
    private $userGroupFactory;

/**
     * @var UserFactory
     */
    private $userFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param UserGroupFactory $userGroupFactory
     * @param UserFactory $userFactory
     */
    public function __construct($store, $log, $userGroupFactory, $userFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->userGroupFactory = $userGroupFactory;
        $this->userFactory = $userFactory;
    }

/**
     *
     */
    public function __clone()
    {
        // Clear the groupId
        $this->groupId = null;
    }

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('ID = %d, Group = %s, IsUserSpecific = %d', $this->groupId, $this->group, $this->isUserSpecific);
    }

/**
     * Generate a unique hash for this User Group
     */
    private function hash()
    {
        return md5(json_encode($this));
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->groupId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return 0;
    }

/**
     * Set the Owner of this Group
     * @param User $user
     */
    public function setOwner($user)
    {
        $this->load();

$this->isUserSpecific = 1;
        $this->isEveryone = 0;
        $this->assignUser($user);
    }

/**
     * Assign User
     * @param User $user
     */
    public function assignUser($user)
    {
        $this->load();

if (!in_array($user, $this->users))
            $this->users[] = $user;
    }

/**
     * Unassign User
     * @param User $user
     */
    public function unassignUser($user)
    {
        $this->load();

$this->users = array_udiff($this->users, [$user], function($a, $b) {
            /**
             * @var User $a
             * @var User $b
             */
            return $a->getId() - $b->getId();
        });
    }

/**
     * Validate
     */
    public function validate()
    {
        if (!v::stringType()->length(1, 50)->validate($this->group))
            throw new InvalidArgumentException(__('User Group Name cannot be empty.') . $this, 'name');

if ($this->libraryQuota !== null && !v::intType()->validate($this->libraryQuota))
            throw new InvalidArgumentException(__('Library Quota must be a whole number.'), 'libraryQuota');

try {
            $group = $this->userGroupFactory->getByName($this->group, $this->isUserSpecific);

if ($this->groupId == null || $this->groupId != $group->groupId)
                throw new DuplicateEntityException(__('There is already a group with this name. Please choose another.'));
        }
        catch (NotFoundException $e) {

}
    }

/**
     * Load this User Group
     * @param array $options
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadUsers' => true
        ], $options);

if ($this->loaded || $this->groupId == 0)
            return;

if ($options['loadUsers']) {
            if ($this->userFactory == null)
                throw new \RuntimeException('Cannot load without first calling setChildObjectDependencies');

// Load all assigned users
            $this->users = $this->userFactory->getByGroupId($this->groupId);
        }

// Set the hash
        $this->hash = $this->hash();
        $this->loaded = true;
    }

/**
     * Save the group
     * @param array $options
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'linkUsers' => true
        ], $options);

if ($options['validate'])
            $this->validate();

if ($this->groupId == null || $this->groupId == 0)
            $this->add();
        else if ($this->hash() != $this->hash)
            $this->edit();

if ($options['linkUsers']) {
            $this->linkUsers();
            $this->unlinkUsers();
        }
    }

/**
     * Delete this Group
     */
    public function delete()
    {
        // We must ensure everything is loaded before we delete
        if ($this->hash == null)
            $this->load();

// Unlink users
        $this->removeAssignments();

$this->getStore()->update('DELETE FROM `permission` WHERE groupId = :groupId', ['groupId' => $this->groupId]);
        $this->getStore()->update('DELETE FROM `group` WHERE groupId = :groupId', ['groupId' => $this->groupId]);
    }

/**
     * Remove all assignments
     */
    private function removeAssignments()
    {
        // Delete Notifications
        // NB: notifications aren't modelled as child objects because there could be many thousands of notifications on each
        // usergroup. We consider the notification to be the parent here and it manages the assignments.
        // This does mean that we might end up with an empty notification (not assigned to anything)
        $this->getStore()->update('DELETE FROM `lknotificationuser` WHERE `userId` IN (SELECT `userId` FROM `lkusergroup` WHERE `groupId` = :groupId) ', ['groupId' => $this->groupId]);
        $this->getStore()->update('DELETE FROM `lknotificationgroup` WHERE `groupId` = :groupId', ['groupId' => $this->groupId]);

// Remove user assignments
        $this->users = [];
        $this->unlinkUsers();
    }

/**
     * Add
     */
    private function add()
    {
        $this->groupId = $this->getStore()->insert('INSERT INTO `group` (`group`, IsUserSpecific, libraryQuota, `isSystemNotification`, `isDisplayNotification`)
              VALUES (:group, :isUserSpecific, :libraryQuota, :isSystemNotification, :isDisplayNotification)', [
            'group' => $this->group,
            'isUserSpecific' => $this->isUserSpecific,
            'libraryQuota' => $this->libraryQuota,
            'isSystemNotification' => $this->isSystemNotification,
            'isDisplayNotification' => $this->isDisplayNotification
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $this->getStore()->update('
          UPDATE `group` SET 
            `group` = :group, 
            libraryQuota = :libraryQuota, 
            `isSystemNotification` = :isSystemNotification,
            `isDisplayNotification` = :isDisplayNotification 
           WHERE groupId = :groupId
        ', [
            'groupId' => $this->groupId,
            'group' => $this->group,
            'libraryQuota' => $this->libraryQuota,
            'isSystemNotification' => $this->isSystemNotification,
            'isDisplayNotification' => $this->isDisplayNotification
        ]);
    }

/**
     * Link Users
     */
    private function linkUsers()
    {
        $insert = $this->getStore()->getConnection()->prepare('INSERT INTO `lkusergroup` (groupId, userId) VALUES (:groupId, :userId) ON DUPLICATE KEY UPDATE groupId = groupId');

foreach ($this->users as $user) {
            /* @var User $user */
            $this->getLog()->debug('Linking %s to %s', $user->userName, $this->group);

$insert->execute([
                'groupId' => $this->groupId,
                'userId' => $user->userId
            ]);
        }
    }

/**
     * Unlink Users
     */
    private function unlinkUsers()
    {
        $params = ['groupId' => $this->groupId];

$sql = 'DELETE FROM `lkusergroup` WHERE groupId = :groupId AND userId NOT IN (0';

$i = 0;
        foreach ($this->users as $user) {
            /* @var User $user */
            $i++;
            $sql .= ',:userId' . $i;
            $params['userId' . $i] = $user->userId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }
}PK�������qYi3.��������Resolution.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (Resolution.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Resolution
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Resolution implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Resolution")
     * @var int
     */
    public $resolutionId;

/**
     * @SWG\Property(description="The resolution name")
     * @var string
     */
    public $resolution;

/**
     * @SWG\Property(description="The display width of the resolution")
     * @var double
     */
    public $width;

/**
     * @SWG\Property(description="The display height of the resolution")
     * @var double
     */
    public $height;

/**
     * @SWG\Property(description="The designer width of the resolution")
     * @var double
     */
    public $designerWidth;

/**
     * @SWG\Property(description="The designer height of the resolution")
     * @var double
     */
    public $designerHeight;

/**
     * @SWG\Property(description="The layout schema version")
     * @var int
     */
    public $version = 2;

/**
     * @SWG\Property(description="A flag indicating whether this resolution is enabled or not")
     * @var int
     */
    public $enabled = 1;

/**
     * @SWG\Property(description="The userId who owns this Resolution")
     * @var int
     */
    public $userId;

/**
     * @return int
     */
    public function getId()
    {
        return $this->resolutionId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        // No owner
        return $this->userId;
    }

public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->resolution))
            throw new InvalidArgumentException(__('Please provide a name'), 'name');

if (!v::intType()->notEmpty()->min(1)->validate($this->width))
            throw new InvalidArgumentException(__('Please provide a width'), 'width');

if (!v::intType()->notEmpty()->min(1)->validate($this->height))
            throw new InvalidArgumentException(__('Please provide a height'), 'height');

// Set the designer width and height
        $factor = min (800 / $this->width, 800 / $this->height);

$this->designerWidth = round($this->width * $factor);
        $this->designerHeight = round($this->height * $factor);
    }

/**
     * Save
     * @param bool|true $validate
     */
    public function save($validate = true)
    {
        if ($validate)
            $this->validate();

if ($this->resolutionId == null || $this->resolutionId == 0)
            $this->add();
        else
            $this->edit();

$this->getLog()->audit('Resolution', $this->resolutionId, 'Saving', $this->getChangedProperties());
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM resolution WHERE resolutionID = :resolutionId', ['resolutionId' => $this->resolutionId]);
    }

private function add()
    {
        $this->resolutionId = $this->getStore()->insert('
          INSERT INTO `resolution` (resolution, width, height, intended_width, intended_height, version, enabled, `userId`)
            VALUES (:resolution, :width, :height, :intended_width, :intended_height, :version, :enabled, :userId)
        ', [
            'resolution' => $this->resolution,
            'width' => $this->designerWidth,
            'height' => $this->designerHeight,
            'intended_width' => $this->width,
            'intended_height' => $this->height,
            'version' => $this->version,
            'enabled' => $this->enabled,
            'userId' => $this->userId
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
          UPDATE resolution SET resolution = :resolution,
                width = :width,
                height = :height,
                intended_width = :intended_width,
                intended_height = :intended_height,
                enabled = :enabled
           WHERE resolutionID = :resolutionId
        ', [
            'resolutionId' => $this->resolutionId,
            'resolution' => $this->resolution,
            'width' => $this->designerWidth,
            'height' => $this->designerHeight,
            'intended_width' => $this->width,
            'intended_height' => $this->height,
            'enabled' => $this->enabled
        ]);
    }
}PK�������qY�MD8�5���5����DataSetColumn.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (DataSetColumn.php)
 */

namespace Xibo\Entity;
use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Factory\DataSetColumnFactory;
use Xibo\Factory\DataSetColumnTypeFactory;
use Xibo\Factory\DataTypeFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DataSetColumn
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DataSetColumn implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this DataSetColumn")
     * @var int
     */
    public $dataSetColumnId;

/**
     * @SWG\Property(description="The ID of the DataSet that this Column belongs to")
     * @var int
     */
    public $dataSetId;

/**
     * @SWG\Property(description="The Column Heading")
     * @var string
     */
    public $heading;

/**
     * @SWG\Property(description="The ID of the DataType for this Column")
     * @var int
     */
    public $dataTypeId;

/**
     * @SWG\Property(description="The ID of the ColumnType for this Column")
     * @var int
     */
    public $dataSetColumnTypeId;

/**
     * @SWG\Property(description="Comma separated list of valid content for drop down columns")
     * @var string
     */
    public $listContent;

/**
     * @SWG\Property(description="The order this column should be displayed")
     * @var int
     */
    public $columnOrder;

/**
     * @SWG\Property(description="A MySQL formula for this column")
     * @var string
     */
    public $formula;

/**
     * @SWG\Property(description="The data type for this Column")
     * @var string
     */
    public $dataType;

/**
     * @SWG\Property(description="The data field of the remote DataSet as a JSON-String")
     * @var string
     */
    public $remoteField;

/**
     * @SWG\Property(description="Does this column show a filter on the data entry page?")
     * @var string
     */
    public $showFilter = 0;

/**
     * @SWG\Property(description="Does this column allow a sorting on the data entry page?")
     * @var string
     */
    public $showSort = 0;

/**
     * @SWG\Property(description="The column type for this Column")
     * @var string
     */
    public $dataSetColumnType;

/** @var  DataSetColumnFactory */
    private $dataSetColumnFactory;

/** @var  DataTypeFactory */
    private $dataTypeFactory;

/** @var  DataSetColumnTypeFactory */
    private $dataSetColumnTypeFactory;

/**
     * The prior dataset column id, when cloning
     * @var int
     */
    public $priorDatasetColumnId;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param DataSetColumnFactory $dataSetColumnFactory
     * @param DataTypeFactory $dataTypeFactory
     * @param DataSetColumnTypeFactory $dataSetColumnTypeFactory
     */
    public function __construct($store, $log, $dataSetColumnFactory, $dataTypeFactory, $dataSetColumnTypeFactory)
    {
        $this->excludeProperty('priorDatasetColumnId');
        $this->setCommonDependencies($store, $log);

$this->dataSetColumnFactory = $dataSetColumnFactory;
        $this->dataTypeFactory = $dataTypeFactory;
        $this->dataSetColumnTypeFactory = $dataSetColumnTypeFactory;
    }

/**
     * Clone
     */
    public function __clone()
    {
        $this->priorDatasetColumnId = $this->dataSetColumnId;
        $this->dataSetColumnId = null;
        $this->dataSetId = null;
    }

/**
     * List Content Array
     * @return array
     */
    public function listContentArray()
    {
        return explode(',', $this->listContent);
    }

/**
     * Validate
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if ($this->dataSetId == 0 || $this->dataSetId == '')
            throw new InvalidArgumentException(__('Missing dataSetId'), 'dataSetId');

if ($this->dataTypeId == 0 || $this->dataTypeId == '')
            throw new InvalidArgumentException(__('Missing dataTypeId'), 'dataTypeId');

if ($this->dataSetColumnTypeId == 0 || $this->dataSetColumnTypeId == '')
            throw new InvalidArgumentException(__('Missing dataSetColumnTypeId'), 'dataSetColumnTypeId');

if ($this->heading == '')
            throw new InvalidArgumentException(__('Please provide a column heading.'), 'heading');

if (!v::stringType()->alnum()->validate($this->heading) || strtolower($this->heading) == 'id')
            throw new InvalidArgumentException(__('Please provide an alternative column heading %s can not be used.', $this->heading), 'heading');

if ($this->dataSetColumnTypeId == 2 && $this->formula == '') {
            throw new InvalidArgumentException(__('Please enter a valid formula'), 'formula');
        }

// Make sure this column name is unique
        $columns = $this->dataSetColumnFactory->getByDataSetId($this->dataSetId);

foreach ($columns as $column) {
            if ($column->heading == $this->heading && ($this->dataSetColumnId == null || $column->dataSetColumnId != $this->dataSetColumnId))
                throw new InvalidArgumentException(__('A column already exists with this name, please choose another'), 'heading');
        }

// Check the actual values
        try {
            $this->dataTypeFactory->getById($this->dataTypeId);
        } catch (NotFoundException $e) {
            throw new InvalidArgumentException(__('Provided Data Type doesn\'t exist'), 'datatype');
        }

try {
            $dataSetColumnType = $this->dataSetColumnTypeFactory->getById($this->dataSetColumnTypeId);

// If we are a remote column, validate we have a field
            if (strtolower($dataSetColumnType->dataSetColumnType) === 'remote' && ($this->remoteField === '' || $this->remoteField === null))
                throw new InvalidArgumentException(__('Remote field is required when the column type is set to Remote'), 'remoteField');

} catch (NotFoundException $e) {
            throw new InvalidArgumentException(__('Provided DataSet Column Type doesn\'t exist'), 'dataSetColumnTypeId');
        }

// Should we validate the list content?
        if ($this->dataSetColumnId != 0 && $this->listContent != '') {
            // Look up all DataSet data in this table to make sure that the existing data is covered by the list content
            $list = $this->listContentArray();

// Add an empty field
            $list[] = '';

// We can check this is valid by building up a NOT IN sql statement, if we get results.. we know its not good
            $select = '';

$dbh = $this->getStore()->getConnection();

for ($i=0; $i < count($list); $i++) {
                $list_val = $dbh->quote($list[$i]);
                $select .= $list_val . ',';
            }

$select = rtrim($select, ',');

// $select has been quoted in the for loop - always test the original value of the column (we won't have changed the actualised table yet)
            $SQL = 'SELECT id FROM `dataset_' . $this->dataSetId . '` WHERE `' . $this->getOriginalValue('heading') . '` NOT IN (' . $select . ')';

$sth = $dbh->prepare($SQL);
            $sth->execute(array(
                'datasetcolumnid' => $this->dataSetColumnId
            ));

if ($sth->fetch())
                throw new InvalidArgumentException(__('New list content value is invalid as it does not include values for existing data'), 'listcontent');
        }

// if formula dataSetType is set and formula is not empty, try to execute the SQL to validate it - we're ignoring client side formulas here.
        if ($this->dataSetColumnTypeId == 2 && $this->formula != '' && substr($this->formula, 0, 1) !== '$') {
           try {
               $formula = str_replace('[DisplayId]', 0, $this->formula);
               $this->getStore()->select('SELECT * FROM (SELECT `id`, ' . $formula . ' AS `' . $this->heading . '`  FROM `dataset_' . $this->dataSetId . '`) dataset WHERE 1 = 1 ', []);
           } catch (\Exception $e) {
               $this->getLog()->debug('Formula validation failed with following message ' . $e->getMessage());
               throw new InvalidArgumentException(__('Provided formula is invalid'), 'formula');
           }
        }
    }

/**
     * Save
     * @param array[Optional] $options
     * @throws InvalidArgumentException
     */
    public function save($options = [])
    {
        $options = array_merge(['validate' => true, 'rebuilding' => false], $options);

if ($options['validate'] && !$options['rebuilding'])
            $this->validate();
        if ($this->dataSetColumnId == 0)
            $this->add();
        else
            $this->edit($options);
    }

/**
     * Delete
     */
    public function delete()
    {
        $this->getStore()->update('DELETE FROM `datasetcolumn` WHERE DataSetColumnID = :dataSetColumnId', ['dataSetColumnId' => $this->dataSetColumnId]);

// Delete column
        if (($this->dataSetColumnTypeId == 1) || ($this->dataSetColumnTypeId == 3)) {
            $this->getStore()->update('ALTER TABLE `dataset_' . $this->dataSetId . '` DROP `' . $this->heading . '`', []);
        }
    }

/**
     * Add
     */
    private function add()
    {
        $this->dataSetColumnId = $this->getStore()->insert('
        INSERT INTO `datasetcolumn` (DataSetID, Heading, DataTypeID, ListContent, ColumnOrder, DataSetColumnTypeID, Formula, RemoteField, `showFilter`, `showSort`)
          VALUES (:dataSetId, :heading, :dataTypeId, :listContent, :columnOrder, :dataSetColumnTypeId, :formula, :remoteField, :showFilter, :showSort)
        ', [
            'dataSetId' => $this->dataSetId,
            'heading' => $this->heading,
            'dataTypeId' => $this->dataTypeId,
            'listContent' => $this->listContent,
            'columnOrder' => $this->columnOrder,
            'dataSetColumnTypeId' => $this->dataSetColumnTypeId,
            'formula' => $this->formula,
            'remoteField' => $this->remoteField,
            'showFilter' => $this->showFilter,
            'showSort' => $this->showSort
        ]);

// Add Column to Underlying Table
        if (($this->dataSetColumnTypeId == 1) || ($this->dataSetColumnTypeId == 3)) {
            // Use a separate connection for DDL (it operates outside transactions)
            $this->getStore()->isolated('ALTER TABLE `dataset_' . $this->dataSetId . '` ADD `' . $this->heading . '` ' . $this->sqlDataType() . ' NULL', []);
        }
    }

/**
     * Edit
     * @param array $options
     * @throws InvalidArgumentException
     */
    private function edit($options)
    {
        $params = [
            'dataSetId' => $this->dataSetId,
            'heading' => $this->heading,
            'dataTypeId' => $this->dataTypeId,
            'listContent' => $this->listContent,
            'columnOrder' => $this->columnOrder,
            'dataSetColumnTypeId' => $this->dataSetColumnTypeId,
            'formula' => $this->formula,
            'dataSetColumnId' => $this->dataSetColumnId,
            'remoteField' => $this->remoteField,
            'showFilter' => $this->showFilter,
            'showSort' => $this->showSort
        ];

$sql = '
          UPDATE `datasetcolumn` SET
            dataSetId = :dataSetId,
            Heading = :heading,
            ListContent = :listContent,
            ColumnOrder = :columnOrder,
            DataTypeID = :dataTypeId,
            DataSetColumnTypeID = :dataSetColumnTypeId,
            Formula = :formula,
            RemoteField = :remoteField, 
            `showFilter` = :showFilter, 
            `showSort` = :showSort
         WHERE dataSetColumnId = :dataSetColumnId 
        ';

$this->getStore()->update($sql, $params);

try {
            if ($options['rebuilding'] && ($this->dataSetColumnTypeId == 1 || $this->dataSetColumnTypeId == 3)) {
                $this->getStore()->isolated('ALTER TABLE `dataset_' . $this->dataSetId . '` ADD `' . $this->heading . '` ' . $this->sqlDataType() . ' NULL', []);

} else if (($this->dataSetColumnTypeId == 1 || $this->dataSetColumnTypeId == 3)
                   && ($this->hasPropertyChanged('heading') || $this->hasPropertyChanged('dataTypeId'))) {
                $sql = 'ALTER TABLE `dataset_' . $this->dataSetId . '` CHANGE `' . $this->getOriginalValue('heading') . '` `' . $this->heading . '` ' . $this->sqlDataType() . ' NULL DEFAULT NULL';
                $this->getStore()->isolated($sql, []);
            }
        } catch (\PDOException $PDOException) {
            $this->getLog()->error('Unable to change DataSetColumn because ' . $PDOException->getMessage());
            throw new InvalidArgumentException(__('Existing data is incompatible with your new configuration'), 'dataSetData');
        }
    }

/**
     * Get the SQL Data Type for this Column Definition
     * @return string
     */
    private function sqlDataType()
    {
        $dataType = null;

switch ($this->dataTypeId) {

case 2:
                $dataType = 'FLOAT';
                break;

case 3:
                $dataType = 'DATETIME';
                break;

case 5:
                $dataType = 'INT';
                break;

case 1:
                $dataType = 'TEXT';
                break;

case 4:
            default:
                $dataType = 'VARCHAR(1000)';
        }

return $dataType;
    }
}PK�������qYI5\��������UserType.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (UserType.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class UserType
 * @package Xibo\Entity
 *
 */
class UserType
{
    use EntityTrait;

public $userTypeId;
    public $userType;

public function getId()
    {
        return $this->userTypeId;
    }

public function getOwnerId()
    {
        return 1;
    }
}PK�������qYi�t�������Setting.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Setting.php)
 */

namespace Xibo\Entity;

/**
 * Class Setting
 * @package Xibo\Entity
 */
class Setting
{
    use EntityTrait;
    public $setting;
    public $value;
}PK�������qY�����|���|��
��Widget.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Xibo\Exception\NotFoundException;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\WidgetAudioFactory;
use Xibo\Factory\WidgetMediaFactory;
use Xibo\Factory\WidgetOptionFactory;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;
use Xibo\Widget\ModuleWidget;

/**
 * Class Widget
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Widget implements \JsonSerializable
{
    public static $DATE_MIN = 0;
    public static $DATE_MAX = 2147483647;

use EntityTrait;

/**
     * @SWG\Property(description="The Widget ID")
     * @var int
     */
    public $widgetId;

/**
     * @SWG\Property(description="The ID of the Playlist this Widget belongs to")
     * @var int
     */
    public $playlistId;

/**
     * @SWG\Property(description="The ID of the User that owns this Widget")
     * @var int
     */
    public $ownerId;

/**
     * @SWG\Property(description="The Module Type Code")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="The duration in seconds this widget should be shown")
     * @var int
     */
    public $duration;

/**
     * @SWG\Property(description="The display order of this widget")
     * @var int
     */
    public $displayOrder;

/**
     * @SWG\Property(description="Flag indicating if this widget has a duration that should be used")
     * @var int
     */
    public $useDuration;

/**
     * @SWG\Property(description="Calculated Duration of this widget after taking into account the useDuration flag")
     * @var int
     */
    public $calculatedDuration = 0;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was created"
     * )
     */
    public $createdDt;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was last modified"
     * )
     */
    public $modifiedDt;

/**
     * @SWG\Property(description="Widget From Date")
     * @var int
     */
    public $fromDt;

/**
     * @SWG\Property(description="Widget To Date")
     * @var int
     */
    public $toDt;

/**
     * @SWG\Property(description="Transition Type In")
     * @var int
     */
    public $transitionIn;

/**
     * @SWG\Property(description="Transition Type out")
     * @var int
     */
    public $transitionOut;

/**
     * @SWG\Property(description="Transition duration in")
     * @var int
     */
    public $transitionDurationIn;

/**
     * @SWG\Property(description="Transition duration out")
     * @var int
     */
    public $transitionDurationOut;

/**
     * @SWG\Property(description="An array of Widget Options")
     * @var WidgetOption[]
     */
    public $widgetOptions = [];

/**
     * @SWG\Property(description="An array of MediaIds this widget is linked to")
     * @var int[]
     */
    public $mediaIds = [];

/**
     * @SWG\Property(description="An array of Audio MediaIds this widget is linked to")
     * @var WidgetAudio[]
     */
    public $audio = [];

/**
     * @SWG\Property(description="An array of permissions for this widget")
     * @var Permission[]
     */
    public $permissions = [];

/**
     * @SWG\Property(description="The Module Object for this Widget")
     * @var ModuleWidget $module
     */
    public $module;

/**
     * @SWG\Property(description="The name of the Playlist this Widget is on")
     * @var string $playlist
     */
    public $playlist;

/**
     * Hash Key of Media Assignments
     * @var string
     */
    private $mediaHash = null;

/**
     * Temporary Id used during import/upgrade/sub-playlist ordering
     * @var string read only string
     */
    public $tempId = null;

/**
     * Flag to indicate whether the widget is newly added
     * @var bool
     */
    public $isNew = false;

/** @var int[] Original Module Media Ids */
    private $originalModuleMediaIds = [];

/** @var array[int] Original Media IDs */
    private $originalMediaIds = [];

/** @var array[WidgetAudio] Original Widget Audio */
    private $originalAudio = [];

/**
     * Minimum duration for widgets
     * @var int
     */
    public static $widgetMinDuration = 1;

//<editor-fold desc="Factories and Dependencies">
    /** @var  DateServiceInterface */
    private $dateService;

/**
     * @var WidgetOptionFactory
     */
    private $widgetOptionFactory;

/**
     * @var WidgetMediaFactory
     */
    private $widgetMediaFactory;

/** @var  WidgetAudioFactory */
    private $widgetAudioFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var  PlaylistFactory */
    private $playlistFactory;
    //</editor-fold>

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param DateServiceInterface $date
     * @param WidgetOptionFactory $widgetOptionFactory
     * @param WidgetMediaFactory $widgetMediaFactory
     * @param WidgetAudioFactory $widgetAudioFactory
     * @param PermissionFactory $permissionFactory
     * @param DisplayFactory $displayFactory
     */
    public function __construct($store, $log, $date, $widgetOptionFactory, $widgetMediaFactory, $widgetAudioFactory, $permissionFactory, $displayFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->excludeProperty('module');
        $this->dateService = $date;
        $this->widgetOptionFactory = $widgetOptionFactory;
        $this->widgetMediaFactory = $widgetMediaFactory;
        $this->widgetAudioFactory = $widgetAudioFactory;
        $this->permissionFactory = $permissionFactory;
        $this->displayFactory = $displayFactory;
    }

/**
     * @param PlaylistFactory $playlistFactory
     * @return $this
     */
    public function setChildObjectDepencencies($playlistFactory)
    {
        $this->playlistFactory = $playlistFactory;
        return $this;
    }

public function __clone()
    {
        $this->hash = null;
        $this->widgetId = null;
        $this->widgetOptions = array_map(function ($object) { return clone $object; }, $this->widgetOptions);
        $this->permissions = [];

// No need to clone the media, but we should empty the original arrays of ids
        $this->originalMediaIds = [];
        $this->originalAudio = [];
    }

/**
     * String
     * @return string
     */
    public function __toString()
    {
        return sprintf('Widget. %s on playlist %d in position %d. WidgetId = %d', $this->type, $this->playlistId, $this->displayOrder, $this->widgetId);
    }

/**
     * Unique Hash
     * @return string
     */
    private function hash()
    {
        return md5($this->widgetId
            . $this->playlistId
            . $this->ownerId
            . $this->type
            . $this->duration
            . $this->displayOrder
            . $this->useDuration
            . $this->calculatedDuration
            . $this->fromDt
            . $this->toDt
            . json_encode($this->widgetOptions)
        );
    }

/**
     * Hash of all media id's
     * @return string
     */
    private function mediaHash()
    {
        sort($this->mediaIds);
        return md5(implode(',', $this->mediaIds));
    }

/**
     * Get the Id
     * @return int
     */
    public function getId()
    {
        return $this->widgetId;
    }

/**
     * Get the OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Set the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->ownerId = $ownerId;
    }

/**
     * Get Option
     * @param string $option
     * @return WidgetOption
     * @throws NotFoundException
     */
    public function getOption($option)
    {
        foreach ($this->widgetOptions as $widgetOption) {
            /* @var WidgetOption $widgetOption */
            if (strtolower($widgetOption->option) == strtolower($option))
                return $widgetOption;
        }

throw new NotFoundException('Widget Option not found');
    }

/**
     * Get Widget Option Value
     * @param string $option
     * @param mixed $default
     * @return mixed
     */
    public function getOptionValue($option, $default)
    {
        try {
            $widgetOption = $this->getOption($option);
            $widgetOption = (($widgetOption->value) === null) ? $default : $widgetOption->value;

if (is_integer($default))
                $widgetOption = intval($widgetOption);

return $widgetOption;
        }
        catch (NotFoundException $e) {
            return $default;
        }
    }

/**
     * Set Widget Option Value
     * @param string $option
     * @param string $type
     * @param mixed $value
     */
    public function setOptionValue($option, $type, $value)
    {
        try {
            $widgetOption = $this->getOption($option);
            $widgetOption->type = $type;
            $widgetOption->value = $value;
        }
        catch (NotFoundException $e) {
            $this->widgetOptions[] = $this->widgetOptionFactory->create($this->widgetId, $type, $option, $value);
        }
    }

/**
     * Assign File Media
     * @param int $mediaId
     */
    public function assignMedia($mediaId)
    {
        $this->load();

if (!in_array($mediaId, $this->mediaIds))
            $this->mediaIds[] = $mediaId;
    }

/**
     * Unassign File Media
     * @param int $mediaId
     */
    public function unassignMedia($mediaId)
    {
        $this->load();

$this->mediaIds = array_diff($this->mediaIds, [$mediaId]);
    }

/**
     * Count media
     * @return int count of media
     */
    public function countMedia()
    {
        $this->load();
        return count($this->mediaIds);
    }

/**
     * @return int
     * @throws NotFoundException
     */
    public function getPrimaryMediaId()
    {
        $primary = $this->getPrimaryMedia();

if (count($primary) <= 0)
            throw new NotFoundException(__('No file to return'));

return $primary[0];
    }

/**
     * Get Primary Media
     * @return int[]
     */
    public function getPrimaryMedia()
    {
        $this->load();

$this->getLog()->debug('Getting first primary media for Widget: ' . $this->widgetId . ' Media: ' . json_encode($this->mediaIds) . ' audio ' . json_encode($this->getAudioIds()));

if (count($this->mediaIds) <= 0)
            return [];

// Remove the audio media from this array
        return array_values(array_diff($this->mediaIds, $this->getAudioIds()));
    }

/**
     * Clear Media
     *  this must only clear module media, not "primary" media
     */
    public function clearCachedMedia()
    {
        $this->load();
        $this->mediaIds = array_values(array_diff($this->mediaIds, $this->originalModuleMediaIds));
    }

/**
     * Assign Audio Media
     * @param WidgetAudio $audio
     */
    public function assignAudio($audio)
    {
        $this->load();

$found = false;
        foreach ($this->audio as $existingAudio) {
            if ($existingAudio->mediaId == $audio->mediaId) {
                $existingAudio->loop = $audio->loop;
                $existingAudio->volume = $audio->volume;
                $found = true;
                break;
            }
        }

if (!$found)
            $this->audio[] = $audio;

// Assign the media
        $this->assignMedia($audio->mediaId);
    }

/**
     * Unassign Audio Media
     * @param int $mediaId
     */
    public function assignAudioById($mediaId)
    {
        $this->load();

$widgetAudio = $this->widgetAudioFactory->createEmpty();
        $widgetAudio->mediaId = $mediaId;
        $widgetAudio->volume = 100;
        $widgetAudio->loop = 0;

$this->assignAudio($widgetAudio);
    }

/**
     * Unassign Audio Media
     * @param WidgetAudio $audio
     */
    public function unassignAudio($audio)
    {
        $this->load();

$this->audio = array_udiff($this->audio, [$audio], function($a, $b) {
            /**
             * @var WidgetAudio $a
             * @var WidgetAudio $b
             */
            return $a->getId() - $b->getId();
        });

// Unassign the media
        $this->unassignMedia($audio->mediaId);
    }

/**
     * Unassign Audio Media
     * @param int $mediaId
     */
    public function unassignAudioById($mediaId)
    {
        $this->load();

foreach ($this->audio as $audio) {

if ($audio->mediaId == $mediaId)
                $this->unassignAudio($audio);
        }
    }

/**
     * Count Audio
     * @return int
     */
    public function countAudio()
    {
        $this->load();

return count($this->audio);
    }

/**
     * Get AudioIds
     * @return int[]
     */
    public function getAudioIds()
    {
        $this->load();

return array_map(function($element) {
            /** @var WidgetAudio $element */
            return $element->mediaId;
        }, $this->audio);
    }

/**
     * Have the media assignments changed.
     */
    public function hasMediaChanged()
    {
        return ($this->mediaHash != $this->mediaHash());
    }

/**
     * @return bool true if this widget has an expiry date
     */
    public function hasExpiry()
    {
        return $this->toDt !== self::$DATE_MAX;
    }

/**
     * @return bool true if this widget has expired
     */
    public function isExpired()
    {
        return ($this->toDt !== self::$DATE_MAX && $this->dateService->parse($this->toDt, 'U') < $this->dateService->parse());
    }

/**
     * Calculates the duration of this widget according to some rules
     * @param $module ModuleWidget
     * @param bool $import
     * @return $this
     */
    public function calculateDuration($module, $import = false)
    {
        $this->getLog()->debug('Calculating Duration - existing value is ' . $this->calculatedDuration);

// Does our widget have a durationIsPerItem and a Number of Items?
        $numItems = $this->getOptionValue('numItems', 0);

// Determine the duration of this widget
        if ($this->type === 'subplaylist') {
            // We use the module to calculate the duration
            $this->calculatedDuration = $module->getSubPlaylistResolvedDuration();

} else if ($this->getOptionValue('durationIsPerItem', 0) == 1 && $numItems > 1) {
            // If we have paging involved then work out the page count.
            $itemsPerPage = $this->getOptionValue('itemsPerPage', 0);
            if ($itemsPerPage > 0) {
                $numItems = ceil($numItems / $itemsPerPage);
            }

// For import
            // in the layout.xml file the duration associated with widget that has all the above parameters
            // will already be the calculatedDuration ie $this->duration from xml is duration * (numItems/itemsPerPage)
            // since we preserve the itemsPerPage, durationIsPerItem and numItems on imported layout, we need to ensure we set the duration correctly
            // this will ensure that both, the widget duration and calculatedDuration will be correct on import.
            if ($import) {
                $this->duration = (($this->useDuration == 1) ? $this->duration / $numItems : $module->getModule()->defaultDuration);
            }

$this->calculatedDuration = (($this->useDuration == 1) ? $this->duration : $module->getModule()->defaultDuration) * $numItems;
        } else if ($this->useDuration == 1) {
            // Widget duration is as specified
            $this->calculatedDuration = $this->duration;

} else if ($this->type === 'video' || $this->type === 'audio') {
            // The calculated duration is the "real" duration (caters for 0 videos)
            $this->calculatedDuration = $module->getDuration(['real' => true]);

} else {
            // The module default duration.
            $this->calculatedDuration = $module->getModule()->defaultDuration;
        }

$this->getLog()->debug('Set to ' . $this->calculatedDuration);

return $this;
    }

/**
     * Load the Widget
     */
    public function load()
    {
        if ($this->loaded || $this->widgetId == null || $this->widgetId == 0)
            return;

// Load permissions
        $this->permissions = $this->permissionFactory->getByObjectId(get_class(), $this->widgetId);

// Load the widget options
        $this->widgetOptions = $this->widgetOptionFactory->getByWidgetId($this->widgetId);

// Load any media assignments for this widget
        $this->mediaIds = $this->widgetMediaFactory->getByWidgetId($this->widgetId);
        $this->originalMediaIds = $this->mediaIds;
        $this->originalModuleMediaIds = $this->widgetMediaFactory->getModuleOnlyByWidgetId($this->widgetId);

// Load any widget audio assignments
        $this->audio = $this->widgetAudioFactory->getByWidgetId($this->widgetId);
        $this->originalAudio = $this->audio;

$this->hash = $this->hash();
        $this->mediaHash = $this->mediaHash();
        $this->loaded = true;
    }

/**
     * Save the widget
     * @param array $options
     */
    public function save($options = [])
    {
        // Default options
        $options = array_merge([
            'saveWidgetOptions' => true,
            'saveWidgetAudio' => true,
            'saveWidgetMedia' => true,
            'notify' => true,
            'notifyPlaylists' => true,
            'notifyDisplays' => false,
            'audit' => true,
            'alwaysUpdate' => false
        ], $options);

$this->getLog()->debug('Saving widgetId ' . $this->getId() . ' with options. ' . json_encode($options, JSON_PRETTY_PRINT));

// if we are auditing get layout specific campaignId
        if ($options['audit']) {
            $campaignId = 0;
            $layoutId = 0;
            $sql = 'SELECT campaign.campaignId, layout.layoutId FROM playlist INNER JOIN region ON playlist.regionId = region.regionId INNER JOIN layout ON region.layoutId = layout.layoutId INNER JOIN lkcampaignlayout on layout.layoutId = lkcampaignlayout.layoutId INNER JOIN campaign ON campaign.campaignId = lkcampaignlayout.campaignId WHERE campaign.isLayoutSpecific = 1 AND playlist.playlistId = :playlistId ;';
            $params = ['playlistId' => $this->playlistId];
            $results = $this->store->select($sql, $params);
            foreach ($results as $row) {
                $campaignId = $row['campaignId'];
                $layoutId = $row['layoutId'];
            }
        }

// Add/Edit
        $isNew = false;
        if ($this->widgetId == null || $this->widgetId == 0) {
            $this->add();
            $isNew = true;
        } else if ($this->hash != $this->hash() || $options['alwaysUpdate']) {
            $this->update();
        }

// Save the widget options
        if ($options['saveWidgetOptions']) {
            foreach ($this->widgetOptions as $widgetOption) {
                /* @var \Xibo\Entity\WidgetOption $widgetOption */

// Assert the widgetId
                $widgetOption->widgetId = $this->widgetId;
                $widgetOption->save();
            }
        }

// Save the widget audio
        if ($options['saveWidgetAudio']) {
            foreach ($this->audio as $audio) {
                /* @var \Xibo\Entity\WidgetAudio $audio */

// Assert the widgetId
                $audio->widgetId = $this->widgetId;
                $audio->save();
            }

$removedAudio = array_udiff($this->originalAudio, $this->audio, function($a, $b) {
                /**
                 * @var WidgetAudio $a
                 * @var WidgetAudio $b
                 */
                return $a->getId() - $b->getId();
            });

foreach ($removedAudio as $audio) {
                /* @var \Xibo\Entity\WidgetAudio $audio */

// Assert the widgetId
                $audio->widgetId = $this->widgetId;
                $audio->delete();
            }
        }

// Manage the assigned media
        if ($options['saveWidgetMedia'] || $options['saveWidgetAudio']) {
            $this->linkMedia();
            $this->unlinkMedia();
        }

// Call notify with the notify options passed in
        $this->notify($options);

if ($options['audit']) {
            if ($isNew) {
                $changedProperties = null;
                if ($campaignId != 0 && $layoutId != 0) {
                    $this->audit($this->widgetId, 'Added', ['widgetId' => $this->widgetId, 'type' => $this->type, 'layoutId' => $layoutId, 'campaignId' => $campaignId]);
                }
            } else {
                $changedProperties = $this->getChangedProperties();
                $changedItems = [];

foreach ($this->widgetOptions as $widgetOption) {
                    $itemsProperties = $widgetOption->getChangedProperties();

// for widget options what we get from getChangedProperities is an array with value as key and changed value as value
                    // we want to override the key in the returned array, so that we get a clear option name that was changed
                    if (array_key_exists('value', $itemsProperties)) {
                        $itemsProperties[$widgetOption->option] = $itemsProperties['value'];
                        unset($itemsProperties['value']);
                    }

if (count($itemsProperties) > 0) {
                        $changedItems[] = $itemsProperties;
                    }
                }

if (count($changedItems) > 0) {
                    $changedProperties['widgetOptions'] = json_encode($changedItems, JSON_PRETTY_PRINT);
                }

// if we are editing a widget assigned to a regionPlaylist add the layout specific campaignId to the audit log
                if ($campaignId != 0 && $layoutId != 0) {
                    $changedProperties['campaignId'][] = $campaignId;
                    $changedProperties['layoutId'][] = $layoutId;
                }
            }

$this->audit($this->widgetId, 'Saved', $changedProperties);
        }
    }

/**
     * @param array $options
     */
    public function delete($options = [])
    {
        $options = array_merge([
            'notify' => true,
            'notifyPlaylists' => true,
            'forceNotifyPlaylists' => true,
            'notifyDisplays' => false
        ], $options);

// We must ensure everything is loaded before we delete
        $this->load();

// Delete Permissions
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->deleteAll();
        }

// Delete all Options
        foreach ($this->widgetOptions as $widgetOption) {
            /* @var \Xibo\Entity\WidgetOption $widgetOption */

// Assert the widgetId
            $widgetOption->widgetId = $this->widgetId;
            $widgetOption->delete();
        }

// Delete the widget audio
        foreach ($this->audio as $audio) {
            /* @var \Xibo\Entity\WidgetAudio $audio */

// Assert the widgetId
            $audio->widgetId = $this->widgetId;
            $audio->delete();
        }

// Unlink Media
        $this->mediaIds = [];
        $this->unlinkMedia();

// Delete this
        $this->getStore()->update('DELETE FROM `widget` WHERE widgetId = :widgetId', array('widgetId' => $this->widgetId));

// Call notify with the notify options passed in
        $this->notify($options);

$this->getLog()->debug('Delete Widget Complete');

// Audit
        $this->audit($this->widgetId, 'Deleted', ['widgetId' => $this->widgetId, 'playlistId' => $this->playlistId]);
    }

/**
     * Notify
     * @param $options
     */
    private function notify($options)
    {
        // By default we do nothing in here, options have to be explicitly enabled.
        $options = array_merge([
            'notify' => false,
            'notifyPlaylists' => false,
            'forceNotifyPlaylists' => false,
            'notifyDisplays' => false
        ], $options);

$this->getLog()->debug('Notifying upstream playlist. Notify Layout: ' . $options['notify'] . ' Notify Displays: ' . $options['notifyDisplays']);

// Should we notify the Playlist
        // we do this if the duration has changed on this widget.
        if ($options['forceNotifyPlaylists']|| ($options['notifyPlaylists'] && (
                $this->hasPropertyChanged('calculatedDuration')
                || $this->hasPropertyChanged('fromDt')
                || $this->hasPropertyChanged('toDt')
            ))) {
            // Notify the Playlist
            $this->getStore()->update('UPDATE `playlist` SET requiresDurationUpdate = 1, `modifiedDT` = :modifiedDt WHERE playlistId = :playlistId', [
                'playlistId' => $this->playlistId,
                'modifiedDt' => $this->dateService->getLocalDate()
            ]);
        }

// Notify Layout
        // We do this for draft and published versions of the Layout to keep the Layout Status fresh and the modified
        // date updated.
        if ($options['notify']) {
            // Notify the Layout
            $this->getStore()->update('
                UPDATE `layout` SET `status` = 3, `modifiedDT` = :modifiedDt WHERE layoutId IN (
                  SELECT `region`.layoutId
                    FROM `lkplaylistplaylist`
                      INNER JOIN `playlist`
                      ON `playlist`.playlistId = `lkplaylistplaylist`.parentId
                      INNER JOIN `region`
                      ON `region`.regionId = `playlist`.regionId 
                   WHERE `lkplaylistplaylist`.childId = :playlistId
                )
            ', [
                'playlistId' => $this->playlistId,
                'modifiedDt' => $this->dateService->getLocalDate()
            ]);
        }

// Notify any displays (clearing their cache)
        // this is typically done when there has been a dynamic change to the Widget - i.e. the Layout doesn't need
        // to be rebuilt, but the Widget has some change that will be pushed out through getResource
        if ($options['notifyDisplays']) {
            $this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByPlaylistId($this->playlistId);
        }
    }

private function add()
    {
        $this->getLog()->debug('Adding Widget ' . $this->type . ' to PlaylistId ' . $this->playlistId);

$this->isNew = true;

$sql = '
            INSERT INTO `widget` (`playlistId`, `ownerId`, `type`, `duration`, `displayOrder`, `useDuration`, `calculatedDuration`, `fromDt`, `toDt`, `createdDt`, `modifiedDt`)
            VALUES (:playlistId, :ownerId, :type, :duration, :displayOrder, :useDuration, :calculatedDuration, :fromDt, :toDt, :createdDt, :modifiedDt)
        ';

$this->widgetId = $this->getStore()->insert($sql, array(
            'playlistId' => $this->playlistId,
            'ownerId' => $this->ownerId,
            'type' => $this->type,
            'duration' => $this->duration,
            'displayOrder' => $this->displayOrder,
            'useDuration' => $this->useDuration,
            'calculatedDuration' => $this->calculatedDuration,
            'fromDt' => ($this->fromDt == null) ? self::$DATE_MIN : $this->fromDt,
            'toDt' => ($this->toDt == null) ? self::$DATE_MAX : $this->toDt,
            'createdDt' => ($this->createdDt === null) ? time() : $this->createdDt,
            'modifiedDt' => time()
        ));
    }

private function update()
    {
        $this->getLog()->debug('Saving Widget ' . $this->type . ' on PlaylistId ' . $this->playlistId . ' WidgetId: ' . $this->widgetId);

$sql = '
          UPDATE `widget` SET `playlistId` = :playlistId,
            `ownerId` = :ownerId,
            `type` = :type,
            `duration` = :duration,
            `displayOrder` = :displayOrder,
            `useDuration` = :useDuration,
            `calculatedDuration` = :calculatedDuration,
            `fromDt` = :fromDt,
            `toDt` = :toDt, 
            `modifiedDt` = :modifiedDt
           WHERE `widgetId` = :widgetId
        ';

$params = [
            'playlistId' => $this->playlistId,
            'ownerId' => $this->ownerId,
            'type' => $this->type,
            'duration' => $this->duration,
            'widgetId' => $this->widgetId,
            'displayOrder' => $this->displayOrder,
            'useDuration' => $this->useDuration,
            'calculatedDuration' => $this->calculatedDuration,
            'fromDt' => ($this->fromDt == null) ? self::$DATE_MIN : $this->fromDt,
            'toDt' => ($this->toDt == null) ? self::$DATE_MAX : $this->toDt,
            'modifiedDt' => time()
        ];

$this->getStore()->update($sql, $params);
    }

/**
     * Link Media
     */
    private function linkMedia()
    {
        // Calculate the difference between the current assignments and the original.
        $mediaToLink = array_diff($this->mediaIds, $this->originalMediaIds);

$this->getLog()->debug('Linking %d new media to Widget %d', count($mediaToLink), $this->widgetId);

// TODO: Make this more efficient by storing the prepared SQL statement
        $sql = 'INSERT INTO `lkwidgetmedia` (widgetId, mediaId) VALUES (:widgetId, :mediaId) ON DUPLICATE KEY UPDATE mediaId = :mediaId2';

foreach ($mediaToLink as $mediaId) {

$this->getStore()->insert($sql, array(
                'widgetId' => $this->widgetId,
                'mediaId' => $mediaId,
                'mediaId2' => $mediaId
            ));
        }
    }

/**
     * Unlink Media
     */
    private function unlinkMedia()
    {
        // Calculate the difference between the current assignments and the original.
        $mediaToUnlink = array_diff($this->originalMediaIds, $this->mediaIds);

$this->getLog()->debug('Unlinking %d old media from Widget %d', count($mediaToUnlink), $this->widgetId);

if (count($mediaToUnlink) <= 0)
            return;

// Unlink any media in the collection
        $params = ['widgetId' => $this->widgetId];

$sql = 'DELETE FROM `lkwidgetmedia` WHERE widgetId = :widgetId AND mediaId IN (0';

$i = 0;
        foreach ($mediaToUnlink as $mediaId) {
            $i++;
            $sql .= ',:mediaId' . $i;
            $params['mediaId' . $i] = $mediaId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }
}PK�������qY�j� �� ����EntityTrait.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Xibo\Helper\ObjectVars;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class EntityTrait
 * used by all entities
 * @package Xibo\Entity
 */
trait EntityTrait
{
    private $hash = null;
    private $loaded = false;
    private $permissionsClass = null;
    private $canChangeOwner = true;

public $buttons = [];
    private $jsonExclude = ['buttons', 'jsonExclude', 'originalValues'];

/** @var array Original values hydrated */
    protected $originalValues = [];

/**
     * @var StorageServiceInterface
     */
    private $store;

/**
     * @var LogServiceInterface
     */
    private $log;

/**
     * Set common dependencies.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @return $this
     */
    protected function setCommonDependencies($store, $log)
    {
        $this->store = $store;
        $this->log = $log;
        return $this;
    }

/**
     * Get Store
     * @return StorageServiceInterface
     */
    protected function getStore()
    {
        return $this->store;
    }

/**
     * Get Log
     * @return LogServiceInterface
     */
    protected function getLog()
    {
        return $this->log;
    }

/**
     * Hydrate an entity with properties
     *
     * @param array $properties
     * @param array $options
     *
     * @return self
     */
    public function hydrate(array $properties, $options = [])
    {
        $intProperties = (array_key_exists('intProperties', $options)) ? $options['intProperties'] : [];
        $stringProperties = (array_key_exists('stringProperties', $options)) ? $options['stringProperties'] : [];
        $htmlStringProperties = (array_key_exists('htmlStringProperties', $options)) ? $options['htmlStringProperties'] : [];

foreach ($properties as $prop => $val) {
            if (property_exists($this, $prop)) {

if ((stripos(strrev($prop), 'dI') === 0 || in_array($prop, $intProperties)) && !in_array($prop, $stringProperties))
                    $val = intval($val);
                else if (in_array($prop, $stringProperties))
                    $val = filter_var($val, FILTER_SANITIZE_STRING);
                else if (in_array($prop, $htmlStringProperties))
                    $val = htmlentities($val);

$this->{$prop} =  $val;
                $this->originalValues[$prop] = $val;
            }
        }

return $this;
    }

/**
     * Reset originals to current values
     */
    public function setOriginals()
    {
        foreach ($this->jsonSerialize() as $key => $value) {
            $this->originalValues[$key] = $value;
        }
    }

/**
     * Get the original value of a property
     * @param string $property
     * @return null|mixed
     */
    public function getOriginalValue($property)
    {
        return (isset($this->originalValues[$property])) ? $this->originalValues[$property] : null;
    }

/**
     * Has the provided property been changed from its original value
     * @param string $property
     * @return bool
     */
    public function hasPropertyChanged($property)
    {
        if (!property_exists($this, $property))
            return true;

return $this->getOriginalValue($property) != $this->{$property};
    }

/**
     * @param $property
     * @return bool
     */
    public function propertyOriginallyExisted($property)
    {
        return array_key_exists($property, $this->originalValues);
    }

/**
     * Get all changed properties for this entity
     */
    public function getChangedProperties()
    {
        $changedProperties = [];

foreach ($this->jsonSerialize() as $key => $value) {
            if (!is_array($value) && !is_object($value) && $this->propertyOriginallyExisted($key) && $this->hasPropertyChanged($key)) {
                $changedProperties[$key] = $this->getOriginalValue($key) . ' > ' . $value;
            }
        }

return $changedProperties;
    }

/**
     * Json Serialize
     * @return array
     */
    public function jsonSerialize()
    {
        $exclude = $this->jsonExclude;

$properties = ObjectVars::getObjectVars($this);
        $json = [];
        foreach ($properties as $key => $value) {
            if (!in_array($key, $exclude)) {
                $json[$key] = $value;
            }
        }
        return $json;
    }

/**
     * To Array
     * @return array
     */
    public function toArray()
    {
        return $this->jsonSerialize();
    }

/**
     * Add a property to the excluded list
     * @param string $property
     */
    public function excludeProperty($property)
    {
        $this->jsonExclude[] = $property;
    }

/**
     * Remove a property from the excluded list
     * @param string $property
     */
    public function includeProperty($property)
    {
        $this->jsonExclude = array_diff($this->jsonExclude, [$property]);
    }

/**
     * Get the Permissions Class
     * @return string
     */
    public function permissionsClass()
    {
        return ($this->permissionsClass == null) ? get_class($this) : $this->permissionsClass;
    }

/**
     * Set the Permissions Class
     * @param string $class
     */
    protected function setPermissionsClass($class)
    {
        $this->permissionsClass = $class;
    }

/**
     * Can the owner change?
     * @return bool
     */
    public function canChangeOwner()
    {
        return $this->canChangeOwner && method_exists($this, 'setOwner');
    }

/**
     * @param bool $bool Can the owner be changed?
     */
    protected function setCanChangeOwner($bool)
    {
        $this->canChangeOwner = $bool;
    }

/**
     * @param $entityId
     * @param $message
     * @param array[Optional] $changedProperties
     */
    protected function audit($entityId, $message, $changedProperties = null)
    {
        $class = substr(get_class($this), strrpos(get_class($this), '\\') + 1);

if ($changedProperties === null) {
            // No properties provided, so we should work them out
            // If we have originals, then get changed, otherwise get the current object state
            $changedProperties = (count($this->originalValues) <= 0) ? $this->toArray() : $this->getChangedProperties();
        } else if (count($changedProperties) <= 0) {
            // We provided changed properties, so we only audit if there are some
            return;
        }

$this->getLog()->audit($class, $entityId, $message, $changedProperties);
    }

/**
     * Compare two arrays, both keys and values.
     *
     * @param $array1
     * @param $array2
     * @param bool $compareValues
     * @return array
     */
    public function compareMultidimensionalArrays($array1, $array2, $compareValues = true)
    {
        $result = [];

// go through arrays, compare keys and values
        // the compareValues flag is there for tag unlink - we're interested only in array keys
        foreach ($array1 as $key => $value) {

if (!is_array($array2) || !array_key_exists($key, $array2)) {
                $result[$key] = $value;
                continue;
            }

if ($value != $array2[$key] && $compareValues) {
                $result[$key] = $value;
            }
        }

return $result;
    }
}PK�������qY*�h�������
��Bandwidth.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Bandwidth.php)
 */

namespace Xibo\Entity;
use Xibo\Exception\DeadlockException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Bandwidth
 * @package Xibo\Entity
 *
 */
class Bandwidth
{
    use EntityTrait;

public static $REGISTER = 1;
    public static $RF = 2;
    public static $SCHEDULE = 3;
    public static $GETFILE = 4;
    public static $GETRESOURCE = 5;
    public static $MEDIAINVENTORY = 6;
    public static $NOTIFYSTATUS = 7;
    public static $SUBMITSTATS = 8;
    public static $SUBMITLOG = 9;
    public static $BLACKLIST = 10;
    public static $SCREENSHOT = 11;

public $displayId;
    public $type;
    public $size;

public function save()
    {
        try {
            $this->getStore()->updateWithDeadlockLoop('
            INSERT INTO `bandwidth` (Month, Type, DisplayID, Size)
              VALUES (:month, :type, :displayId, :size)
            ON DUPLICATE KEY UPDATE Size = Size + :size2
        ', [
                'month' => strtotime(date('m') . '/02/' . date('Y') . ' 00:00:00'),
                'type' => $this->type,
                'displayId' => $this->displayId,
                'size' => $this->size,
                'size2' => $this->size
            ]);
        } catch (DeadlockException $deadlockException) {
            $this->getLog()->error('Deadlocked inserting bandwidth');
        }
    }
}PK�������qYᗄ�@���@�����Playlist.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Factory\ModuleFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\TagFactory;
use Xibo\Factory\WidgetFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;
use Xibo\Widget\SubPlaylist;

/**
 * Class Playlist
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Playlist implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Playlist")
     * @var int
     */
    public $playlistId;

/**
     * @SWG\Property(description="The userId of the User that owns this Playlist")
     * @var int
     */
    public $ownerId;

/**
     * @SWG\Property(description="The Name of the Playlist")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="The RegionId if this Playlist is specific to a Region")
     * @var int
     */
    public $regionId;

/**
     * @SWG\Property(description="Flag indicating if this is a dynamic Playlist")
     * @var int
     */
    public $isDynamic;

/**
     * @SWG\Property(description="Filter Name for a Dynamic Playlist")
     * @var string
     */
    public $filterMediaName;

/**
     * @SWG\Property(description="Filter Tags for a Dynamic Playlist")
     * @var string
     */
    public $filterMediaTags;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was created"
     * )
     */
    public $createdDt;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Layout was last modified"
     * )
     */
    public $modifiedDt;

/**
     * @var int
     * @SWG\Property(
     *     description="Flag indicating whether this Playlists requires a duration update"
     * )
     */
    public $requiresDurationUpdate;

/**
     * @var string
     * @SWG\Property(
     *  description="The option to enable the collection of Playlist Proof of Play statistics"
     * )
     */
    public $enableStat;

/**
     * @SWG\Property(description="An array of Tags")
     * @var Tag[]
     */
    public $tags = [];

/**
     * @SWG\Property(description="An array of Widgets assigned to this Playlist")
     * @var Widget[]
     */
    public $widgets = [];

/**
     * @SWG\Property(description="An array of permissions")
     * @var Permission[]
     */
    public $permissions = [];

/**
     * Temporary Id used during import/upgrade
     * @var string read only string
     */
    public $tempId = null;

public $tagValues;

// Read only properties
    public $owner;
    public $groupsWithPermissions;

private $unassignTags = [];

//<editor-fold desc="Factories and Dependencies">

/**
     * @var DateServiceInterface
     */
    private $dateService;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var WidgetFactory
     */
    private $widgetFactory;

/**
     * @var TagFactory
     */
    private $tagFactory;

/**
     * @var PlaylistFactory
     */
    private $playlistFactory;

/** @var ModuleFactory */
    private $moduleFactory;

/**
     * @var ConfigServiceInterface
     */
    private $config;
    //</editor-fold>

*/
    public function __construct($store, $log, $config, $date, $permissionFactory, $playlistFactory, $widgetFactory, $tagFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->config = $config;
        $this->dateService = $date;
        $this->permissionFactory = $permissionFactory;
        $this->playlistFactory = $playlistFactory;
        $this->widgetFactory = $widgetFactory;
        $this->tagFactory = $tagFactory;
    }

/**
     * @param ModuleFactory $moduleFactory
     * @return $this
     */
    public function setModuleFactory($moduleFactory)
    {
        $this->moduleFactory = $moduleFactory;
        return $this;
    }

/**
     * Clone this Playlist
     */
    public function __clone()
    {
        $this->hash = null;
        $this->playlistId = null;
        $this->regionId = null;
        $this->permissions = [];

$this->widgets = array_map(function ($object) { return clone $object; }, $this->widgets);
    }

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('Playlist %s. Widgets = %d. PlaylistId = %d. RegionId = %d', $this->name, count($this->widgets), $this->playlistId, $this->regionId);
    }

/**
     * @return string
     */
    private function hash()
    {
        return md5($this->regionId . $this->playlistId . $this->ownerId . $this->name . $this->duration . $this->requiresDurationUpdate);
    }

/**
     * Get the Id
     * @return int
     */
    public function getId()
    {
        return $this->playlistId;
    }

/**
     * Get the OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->load();
        $this->ownerId = $ownerId;

foreach ($this->widgets as $widget) {
            /* @var Widget $widget */
            $widget->setOwner($ownerId);
        }
    }

/**
     * Is this Playlist a Region Playlist (region specific)
     * @return bool
     */
    public function isRegionPlaylist()
    {
        return ($this->regionId != null);
    }

/**
     * Validate this playlist
     * @throws DuplicateEntityException
     */
    public function validate()
    {
        // check for duplicates,
        // we check for empty playlist name due to layouts existing in the CMS before upgrade to v2
        if ($this->name != '') {
            $duplicates = $this->playlistFactory->query(null, [
                'userId' => $this->ownerId,
                'playlistExact' => $this->name,
                'regionSpecific' => 0,
                'disableUserCheck' => 1,
                'notPlaylistId' => ($this->playlistId == null) ? 0 : $this->playlistId,
            ]);

if (count($duplicates) > 0) {
                throw new DuplicateEntityException(sprintf(__("You already own a Playlist called '%s'. Please choose another name."), $this->name));
            }
        }
    }

/**
     * Is this Playlist editable.
     * Are we a standalone playlist OR are we on a draft layout
     * @return bool
     */
    public function isEditable()
    {
        if ($this->isRegionPlaylist()) {
            // Run a lookup to see if we're on a draft layout
            $this->getLog()->debug('Checking whether we are on a Layout which is in the Draft State');

$exists = $this->getStore()->exists('
                SELECT `layout`.layoutId 
                  FROM `region`
                    INNER JOIN `layout` ON layout.layoutId = region.layoutId 
                 WHERE regionId = :regionId
                  AND parentId IS NOT NULL
            ', [
                'regionId' => $this->regionId
            ]);

$this->getLog()->debug('We are ' . (($exists) ? 'editable' : 'not editable'));

return $exists;
        } else {
            $this->getLog()->debug('Non-region Playlist - we\'re always Editable' );
            return true;
        }
    }

/**
     * Get Widget at Index
     * @param int $index
     * @param Widget[]|null $widgets
     * @return Widget
     * @throws NotFoundException
     */
    public function getWidgetAt($index, $widgets = null)
    {
        if ($widgets === null)
            $widgets = $this->widgets;

if ($index <= count($widgets)) {
            $zeroBased = $index - 1;
            if (isset($widgets[$zeroBased])) {
                return $widgets[$zeroBased];
            }
        }

throw new NotFoundException(sprintf(__('Widget not found at index %d'), $index));
    }

/**
     * Get Widget by Id
     * @param int $widgetId
     * @param Widget[]|null $widgets
     * @return Widget
     * @throws NotFoundException
     */
    public function getWidget($widgetId, $widgets = null)
    {
        if ($widgets === null)
            $widgets = $this->widgets;

foreach ($widgets as $widget) {
            if ($widget->widgetId == $widgetId) {
                return $widget;
            }
        }

throw new NotFoundException(sprintf(__('Widget not found with ID %d'), $widgetId));
    }

/**
     * @param Widget $widget
     * @param int $displayOrder
     */
    public function assignWidget($widget, $displayOrder = null)
    {
        $this->load();

// Has a display order been provided?
        if ($displayOrder !== null) {
            // We need to shuffle any existing widget down to make space for this one.
            foreach ($this->widgets as $existingWidget) {
                if ($existingWidget->displayOrder < $displayOrder) {
                    // Earlier in the list, so do nothing.
                    continue;
                } else {
                    // This widget is >= the display order and therefore needs to be moved down one position.
                    $existingWidget->displayOrder = $existingWidget->displayOrder + 1;
                }

// Set the incoming widget to the requested display order.
                $widget->displayOrder = $displayOrder;
            }
        } else {
            // Take the next available one
            $widget->displayOrder = count($this->widgets) + 1;
        }

$this->widgets[] = $widget;
    }

/**
     * Delete a Widget
     * @param Widget $widget
     * @param array $options Delete Options
     * @return $this
     * @throws \Xibo\Exception\InvalidArgumentException
     */
    public function deleteWidget($widget, $options = [])
    {
        $this->load();

if ($widget->playlistId != $this->playlistId) {
            throw new InvalidArgumentException(__('Cannot delete a Widget that isn\'t assigned to me'), 'playlistId');
        }

// Delete
        $widget->delete($options);

// Remove the Deleted Widget from our Widgets
        $this->widgets = array_udiff($this->widgets, [$widget], function($a, $b) {
            /* @var \Xibo\Entity\Widget $a */
            /* @var \Xibo\Entity\Widget $b */
            return $a->widgetId - $b->widgetId;
        });

return $this;
    }

/**
     * @param Tag[] $tags
     */
    public function replaceTags($tags = [])
    {
        if (!is_array($this->tags) || count($this->tags) <= 0)
            $this->tags = $this->tagFactory->loadByPlaylistId($this->playlistId);

$this->getLog()->debug('Tags to be removed: %s', json_encode($this->unassignTags));

// Replace the arrays
            $this->tags = $tags;

$this->getLog()->debug('Tags remaining: %s', json_encode($this->tags));
        } else {
            $this->getLog()->debug('Tags were not changed');
        }
    }

/**
     * Unassign tag
     * @param Tag $tag
     * @return $this
     */
    public function unassignTag($tag)
    {
        $this->load();

$this->tags = array_udiff($this->tags, [$tag], function($a, $b) {
            /* @var Tag $a */
            /* @var Tag $b */
            return $a->tagId - $b->tagId;
        });

$this->unassignTags[] = $tag;

$this->getLog()->debug('Tags after removal %s', json_encode($this->tags));

return $this;
    }

/**
     * Load
     * @param array $loadOptions
     * @return $this
     */
    public function load($loadOptions = [])
    {
        if ($this->playlistId == null || $this->loaded)
            return $this;

// Options
        $options = array_merge([
            'loadPermissions' => true,
            'loadWidgets' => true,
            'loadTags' => true
        ], $loadOptions);

$this->getLog()->debug('Load Playlist with ' . json_encode($options));

// Load permissions
        if ($options['loadPermissions'])
            $this->permissions = $this->permissionFactory->getByObjectId(get_class(), $this->playlistId);

// Load all tags
        if ($options['loadTags'])
            $this->tags = $this->tagFactory->loadByPlaylistId($this->playlistId);

// Load the widgets
        if ($options['loadWidgets']) {
            foreach ($this->widgetFactory->getByPlaylistId($this->playlistId) as $widget) {
                /* @var Widget $widget */
                $widget->load();
                $this->widgets[] = $widget;
            }
        }

$this->hash = $this->hash();
        $this->loaded = true;

return $this;
    }

/**
     * Save
     * @param array $options
     * @throws \Xibo\Exception\DuplicateEntityException
     * @throws \Xibo\Exception\InvalidArgumentException
     */
    public function save($options = [])
    {
        // Default options
        $options = array_merge([
            'saveTags' => true,
            'saveWidgets' => true,
            'notify' => true,
            'validate' => true,
            'auditPlaylist' => true
        ], $options);

if ($options['validate']) {
            $this->validate();
        }

// if we are auditing and editing a regionPlaylist then get layout specific campaignId
        $campaignId = 0;
        $layoutId = 0;

if ($options['auditPlaylist'] && $this->regionId != null) {
            $sql = 'SELECT campaign.campaignId, layout.layoutId FROM region INNER JOIN layout ON region.layoutId = layout.layoutId INNER JOIN lkcampaignlayout on layout.layoutId = lkcampaignlayout.layoutId INNER JOIN campaign ON campaign.campaignId = lkcampaignlayout.campaignId WHERE campaign.isLayoutSpecific = 1 AND region.regionId = :regionId ;';
            $params = ['regionId' => $this->regionId];
            $results = $this->store->select($sql, $params);
            foreach ($results as $row) {
                $campaignId = $row['campaignId'];
                $layoutId = $row['layoutId'];
            }
        }

if ($this->playlistId == null || $this->playlistId == 0) {
            $this->add();
        } else if ($this->hash != $this->hash()) {
            $this->update();
        } else {
            // Nothing changed wrt the Playlist itself.
            $options['auditPlaylist'] = false;
        }

// Save the widgets?
        if ($options['saveWidgets']) {
            // Sort the widgets by their display order
            usort($this->widgets, function ($a, $b) {
                /**
                 * @var Widget $a
                 * @var Widget $b
                 */
                return $a->displayOrder - $b->displayOrder;
            });

// Assert the Playlist on all widgets and apply a display order
            // this keeps the widgets in numerical order on each playlist
            $i = 0;
            foreach ($this->widgets as $widget) {
                /* @var Widget $widget */
                $i++;

// Assert the playlistId
                $widget->playlistId = $this->playlistId;
                // Assert the displayOrder
                $widget->displayOrder = $i;
                $widget->save($options);
            }
        }

// Save the tags?
        if ($options['saveTags']) {
            $this->getLog()->debug('Saving tags on ' . $this);

// Save the tags
            if (is_array($this->tags)) {
                foreach ($this->tags as $tag) {
                    /* @var Tag $tag */

$this->getLog()->debug('Assigning tag ' . $tag->tag);

$tag->assignPlaylist($this->playlistId);
                    $tag->save();
                }
            }

$tag->unassignPlaylist($this->playlistId);
                    $tag->save();
                }
            }
        }

// Audit
        if ($options['auditPlaylist']) {
            $change = $this->getChangedProperties();

// if we are editing a regionPlaylist then add the layout specific campaignId to the audit log.
            if ($this->regionId != null) {
                $change['campaignId'][] = $campaignId;
                $change['layoutId'][] = $layoutId;
            }

$this->audit($this->playlistId, 'Saved', $change);
        }
    }

/**
     * Delete
     * @param array $options
     * @throws InvalidArgumentException
     */
    public function delete($options = [])
    {
        $options = array_merge([
            'regionDelete' => false
        ], $options);

// We must ensure everything is loaded before we delete
        if (!$this->loaded) {
            $this->load();
        }

if (!$options['regionDelete'] && $this->regionId != 0)
            throw new InvalidArgumentException(__('This Playlist belongs to a Region, please delete the Region instead.'), 'regionId');

// Notify we're going to delete
        // we do this here, because once we've deleted we lose the references for the storage query
        $this->notifyLayouts();

// Delete me from any other Playlists using me as a sub-playlist
        foreach ($this->playlistFactory->query(null, ['childId' => $this->playlistId, 'depth' => 1]) as $parent) {
            // $parent is a playlist to which we belong.
            // find out widget and delete it
            $this->getLog()->debug('This playlist is a sub-playlist in ' . $parent->name . ' we will need to remove it');
            $parent->load();
            foreach ($parent->widgets as $widget) {
                if ($widget->type === 'subplaylist') {
                    // we get an array with all subplaylists assigned to the parent
                    $subPlaylistIds = json_decode($widget->getOptionValue('subPlaylistIds', '[]'));
                    foreach ($subPlaylistIds as $subplaylist) {
                        // find the matching playlistId to the playlistId we want to delete
                        if ($subplaylist == $this->playlistId) {
                            // if there is only one element in the subPlaylistIds array then remove the widget
                            if (count($subPlaylistIds) === 1) {
                                $widget->delete(['notify' => false]);
                            } else {
                                // if the subPlaylistIds has more than one element, we want to just unassign our playlistId from it and save the widget,
                                // we don't want to remove the whole widget in this case
                                $updatedSubplaylistIds = array_diff($subPlaylistIds, [$this->playlistId]);
                                $widget->setOptionValue('subPlaylistIds', 'attrib', json_encode($updatedSubplaylistIds));
                                $widget->save();
                            }
                        }
                    }
                }
            }
        }

// We want to remove all link records from the closure table using the parentId
        $this->getStore()->update('DELETE FROM `lkplaylistplaylist` WHERE parentId = :playlistId', ['playlistId' => $this->playlistId]);

// Delete my closure table records
        $this->getStore()->update('DELETE FROM `lkplaylistplaylist` WHERE childId = :playlistId', ['playlistId' => $this->playlistId]);

// Unassign tags
        foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tag->unassignPlaylist($this->playlistId);
            $tag->save();
        }

// Delete Permissions
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->deleteAll();
        }

// Delete widgets
        foreach ($this->widgets as $widget) {
            /* @var Widget $widget */
            // Assert the playlistId
            $widget->playlistId = $this->playlistId;
            $widget->delete();
        }

// Delete this playlist
        $this->getStore()->update('DELETE FROM `playlist` WHERE playlistId = :playlistId', array('playlistId' => $this->playlistId));

// Audit
        $this->audit($this->playlistId, 'Deleted', ['playlistId' => $this->playlistId, 'regionId' => $this->regionId]);
    }

/**
     * Add
     */
    private function add()
    {
        $this->getLog()->debug('Adding Playlist ' . $this->name);

$time = date('Y-m-d H:i:s');

$sql = '
        INSERT INTO `playlist` (`name`, `ownerId`, `regionId`, `isDynamic`, `filterMediaName`, `filterMediaTags`, `createdDt`, `modifiedDt`, `requiresDurationUpdate`, `enableStat`) 
          VALUES (:name, :ownerId, :regionId, :isDynamic, :filterMediaName, :filterMediaTags, :createdDt, :modifiedDt, :requiresDurationUpdate, :enableStat)
        ';
        $this->playlistId = $this->getStore()->insert($sql, array(
            'name' => $this->name,
            'ownerId' => $this->ownerId,
            'regionId' => $this->regionId == 0 ? null : $this->regionId,
            'isDynamic' => $this->isDynamic,
            'filterMediaName' => $this->filterMediaName,
            'filterMediaTags' => $this->filterMediaTags,
            'createdDt' => $time,
            'modifiedDt' => $time,
            'requiresDurationUpdate' => ($this->requiresDurationUpdate === null) ? 0 : $this->requiresDurationUpdate,
            'enableStat' => $this->enableStat
        ));

// Insert my self link
        $this->getStore()->insert('INSERT INTO `lkplaylistplaylist` (`parentId`, `childId`, `depth`) VALUES (:parentId, :childId, 0)', [
            'parentId' => $this->playlistId,
            'childId' => $this->playlistId
        ]);
    }

/**
     * Update
     */
    private function update()
    {
        $this->getLog()->debug('Updating Playlist ' . $this->name . '. Id = ' . $this->playlistId);

$sql = '
            UPDATE `playlist` SET 
                `name` = :name, 
                `ownerId` = :ownerId,
                `regionId` = :regionId, 
                `modifiedDt` = :modifiedDt, 
                `duration` = :duration,
                `isDynamic` = :isDynamic,
                `filterMediaName` = :filterMediaName,
                `filterMediaTags` = :filterMediaTags,
                `requiresDurationUpdate` = :requiresDurationUpdate,
                `enableStat` = :enableStat
             WHERE `playlistId` = :playlistId
        ';

$this->getStore()->update($sql, array(
            'playlistId' => $this->playlistId,
            'name' => $this->name,
            'ownerId' => $this->ownerId,
            'regionId' => $this->regionId == 0 ? null : $this->regionId,
            'duration' => $this->duration,
            'isDynamic' => $this->isDynamic,
            'filterMediaName' => $this->filterMediaName,
            'filterMediaTags' => $this->filterMediaTags,
            'modifiedDt' => date('Y-m-d H:i:s'),
            'requiresDurationUpdate' => $this->requiresDurationUpdate,
            'enableStat' => $this->enableStat
        ));
    }

/**
     * Notify all Layouts of a change to this playlist
     *  This only sets the Layout Status to require a build and to update the layout modified date
     *  once the build is triggered, either from the UI or maintenance it will assess the layout
     *  and call save() if required.
     *  Layout->save() will ultimately notify the interested display groups.
     */
    public function notifyLayouts()
    {
        // Notify the Playlist
        $this->getStore()->update('UPDATE `playlist` SET requiresDurationUpdate = 1, `modifiedDT` = :modifiedDt WHERE playlistId = :playlistId', [
            'playlistId' => $this->playlistId,
            'modifiedDt' => $this->dateService->getLocalDate()
        ]);

$this->getStore()->update('
            UPDATE `layout` SET `status` = 3, `modifiedDT` = :modifiedDt WHERE layoutId IN (
              SELECT `region`.layoutId
                FROM `lkplaylistplaylist`
                  INNER JOIN `playlist`
                  ON `playlist`.playlistId = `lkplaylistplaylist`.parentId
                  INNER JOIN `region`
                  ON `region`.regionId = `playlist`.regionId 
               WHERE `lkplaylistplaylist`.childId = :playlistId
            )
        ', [
            'playlistId' => $this->playlistId,
            'modifiedDt' => $this->dateService->getLocalDate()
        ]);
    }

/**
     * Expand this Playlists widgets according to any sub-playlists that are present
     * @param int $parentWidgetId this tracks the top level widgetId
     * @param bool $expandSubplaylists
     * @return Widget[]
     * @throws InvalidArgumentException
     * @throws NotFoundException
     */
    public function expandWidgets($parentWidgetId = 0, $expandSubplaylists = true)
    {
        $this->load();

$widgets = [];

// Start with our own Widgets
        foreach ($this->widgets as $widget) {

// some basic checking on whether this widets date/time are conductive to it being added to the
            // list. This is really an "expires" check, because we will rely on the player otherwise
            if ($widget->isExpired())
                continue;

// Persist the parentWidgetId in a temporary variable
            // if we have a parentWidgetId of 0, then we are top-level and we should use our widgetId
            $widget->tempId = $parentWidgetId == 0 ? $widget->widgetId : $parentWidgetId;

// If we're a standard widget, add right away
            if ($widget->type !== 'subplaylist') {
                $widgets[] = $widget;
            } else {
                if ($expandSubplaylists === true) {
                    /** @var SubPlaylist $module */
                    $module = $this->moduleFactory->createWithWidget($widget);
                    $module->isValid();

$widgets = array_merge($widgets, $module->getSubPlaylistResolvedWidgets($widget->tempId));
                }
            }
        }

return $widgets;
    }

/**
     * Update Playlist Duration
     *  this is called by the system maintenance task to keep all Playlists durations updated
     *  we should edit this playlist duration (noting the delta) and then find all Playlists of which this is
     *  a sub-playlist and update their durations also (cascade upward)
     * @return $this
     * @throws NotFoundException
     * @throws \Xibo\Exception\DuplicateEntityException
     */
    public function updateDuration()
    {
        // Update this Playlists Duration - get a SUM of all widget durations
        $this->load([
            'loadPermissions' => false,
            'loadWidgets' => true,
            'loadTags' => false
        ]);

$duration = 0;
        $removedWidget = false;

// What is the next time we need to update this Playlist (0 is never)
        $nextUpdate = 0;

foreach ($this->widgets as $widget) {
            // Is this widget expired?
            if ($widget->isExpired()) {

// Remove this widget.
                if ($widget->getOptionValue('deleteOnExpiry', 0) == 1) {
                    // Don't notify at all because we're going to do that when we finish updating our duration.
                    $widget->delete([
                        'notify' => false,
                        'notifyPlaylists' => false,
                        'forceNotifyPlaylists' => false,
                        'notifyDisplays' => false
                    ]);

$removedWidget = true;
                }

// Do not assess it
                continue;
            }

// If we're a standard widget, add right away
            if ($widget->type !== 'subplaylist') {
                $duration += $widget->calculatedDuration;

// Does this expire?
                // Log this as the new next update
                if ($widget->hasExpiry() && ($nextUpdate == 0 || $nextUpdate > $widget->toDt)) {
                    $nextUpdate = $widget->toDt;
                }
            } else {
                // Add the sub playlist duration
                /** @var SubPlaylist $module */
                $module = $this->moduleFactory->createWithWidget($widget);
                $duration += $module->getSubPlaylistResolvedDuration();
            }
        }

// Set our "requires duration"
        $delta = $duration - $this->duration;

$this->getLog()->debug('Delta duration after updateDuration ' . $delta);

$this->duration = $duration;
        $this->requiresDurationUpdate = $nextUpdate;

$this->save(['saveTags' => false, 'saveWidgets' => false]);

if ($removedWidget) {
            $this->notifyLayouts();
        }

if ($delta !== 0) {
            // Use the closure table to update all parent playlists (including this one).
            $this->getStore()->update('
                UPDATE `playlist` SET duration = duration + :delta WHERE playlistId IN (
                    SELECT DISTINCT parentId
                      FROM `lkplaylistplaylist`
                     WHERE childId = :playlistId
                      AND parentId <> :playlistId
                )
            ', [
                'delta' => $delta,
                'playlistId' => $this->playlistId
            ]);
        }

return $this;
    }

/**
     * Clone the closure table for a new PlaylistId
     *  usually this is used on Draft creation
     * @param int $newParentId
     */
    public function cloneClosureTable($newParentId)
    {
        $this->getStore()->update('
            INSERT INTO `lkplaylistplaylist` (parentId, childId, depth)
                SELECT :newParentId, childId, depth 
                  FROM lkplaylistplaylist
                 WHERE parentId = :parentId AND depth > 0
        ', [
            'newParentId' => $newParentId,
            'parentId' => $this->playlistId
        ]);
    }

/**
     * Recursive function, that goes through all widgets on nested Playlists.
     *
     * generates nestedPlaylistDefinitions with Playlist ID as the key - later saved as nestedPlaylist.json on export
     * generates playlistMappings which contains all relations between playlists (parent/child) - later saved as playlistMappings.json on export
     * Adds dataSets data to $dataSets parameter - later saved as dataSet.json on export
     *
     * playlistMappings, nestedPLaylistDefinitions, dataSets and dataSetIds are passed by reference.
     *
     *
     * @param $widgets array An array of widgets assigned to the Playlist
     * @param $parentId int Playlist Id of the Playlist that is a parent to our current Playlist
     * @param $playlistMappings array An array of Playlists with ParentId and PlaylistId as keys
     * @param $count
     * @param $nestedPlaylistDefinitions array An array of Playlists including widdgets with playlistId as the key
     * @param $dataSetIds array Array of dataSetIds
     * @param $dataSets array Array of dataSets with dataSets from widgets on the layout level and nested Playlists
     * @param $dataSetFactory
     * @param $includeData bool Flag indicating whether we should include DataSet data in the export
     * @return mixed
     * @throws NotFoundException
     */
    public function generatePlaylistMapping($widgets, $parentId, &$playlistMappings, &$count, &$nestedPlaylistDefinitions, &$dataSetIds, &$dataSets, $dataSetFactory, $includeData)
    {
            foreach ($widgets as $playlistWidget) {

if ($playlistWidget->type == 'subplaylist') {

$nestedPlaylistIds = json_decode($playlistWidget->getOptionValue('subPlaylistIds', []), true);
                    foreach ($nestedPlaylistIds as $nestedPlaylistId) {
                        $nestedPlaylist = $this->playlistFactory->getById($nestedPlaylistId);
                        $nestedPlaylist->load();
                        $this->getLog()->debug('playlist mappings parent id ' . $parentId);
                        $nestedPlaylistDefinitions[$nestedPlaylist->playlistId] = $nestedPlaylist;

$playlistMappings[$parentId][$nestedPlaylist->playlistId] = [
                            'parentId' => $parentId,
                            'playlist' => $nestedPlaylist->name,
                            'playlistId' => $nestedPlaylist->playlistId
                        ];

$count++;

// this is a recursive function, we need to go through all levels of nested Playlists.
                        $this->generatePlaylistMapping($nestedPlaylist->widgets, $nestedPlaylist->playlistId, $playlistMappings, $count, $nestedPlaylistDefinitions,$dataSetIds, $dataSets, $dataSetFactory, $includeData);
                    }
                }

// if we have any widgets that use DataSets we want the dataSetId and data added
                if ($playlistWidget->type == 'datasetview' || $playlistWidget->type == 'datasetticker' || $playlistWidget->type == 'chart') {
                    $dataSetId = $playlistWidget->getOptionValue('dataSetId', 0);

if ($dataSetId != 0) {

if (in_array($dataSetId, $dataSetIds))
                            continue;

// Export the structure for this dataSet
                        $dataSet = $dataSetFactory->getById($dataSetId);
                        $dataSet->load();

// Are we also looking to export the data?
                        if ($includeData) {
                            $dataSet->data = $dataSet->getData([], ['includeFormulaColumns' => false]);
                        }

$dataSetIds[] = $dataSet->dataSetId;
                        $dataSets[] = $dataSet;
                    }
                }
            }

return $playlistMappings;
    }
}PK�������qYrMa���������Session.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Session.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Session
 * @package Xibo\Entity
 */
class Session implements \JsonSerializable
{
    use EntityTrait;

public $sessionId;
    public $userId;
    public $userName;
    public $isExpired;
    public $lastAccessed;
    public $remoteAddress;
    public $userAgent;
    public $expiresAt;

public function getId()
    {
        return $this->userId;
    }

public function getOwnerId()
    {
        return 1;
    }
}PK�������qY�%|��|��	��Media.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\ConfigurationException;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlayerVersionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Factory\TagFactory;
use Xibo\Factory\WidgetFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Media
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Media implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Media ID")
     * @var int
     */
    public $mediaId;

/**
     * @SWG\Property(description="The ID of the User that owns this Media")
     * @var int
     */
    public $ownerId;

/**
     * @SWG\Property(description="The Parent ID of this Media if it has been revised")
     * @var int
     */
    public $parentId;

/**
     * @SWG\Property(description="The Name of this Media")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="The module type of this Media")
     * @var string
     */
    public $mediaType;

/**
     * @SWG\Property(description="The file name of the media as stored in the library")
     * @var string
     */
    public $storedAs;

/**
     * @SWG\Property(description="The original file name as it was uploaded")
     * @var string
     */
    public $fileName;

// Thing that might be referred to
    /**
     * @SWG\Property(description="Tags associated with this Media")
     * @var Tag[]
     */
    public $tags = [];
    public $tagValues;

/**
     * @SWG\Property(description="The file size in bytes")
     * @var int
     */
    public $fileSize;

/**
     * @SWG\Property(description="The duration to use when assigning this media to a Layout widget")
     * @var int
     */
    public $duration = 0;

/**
     * @SWG\Property(description="Flag indicating whether this media is valid.")
     * @var int
     */
    public $valid = 1;

/**
     * @SWG\Property(description="Flag indicating whether this media is a system file or not")
     * @var int
     */
    public $moduleSystemFile = 0;

/**
     * @SWG\Property(description="Timestamp indicating when this media should expire")
     * @var int
     */
    public $expires = 0;

/**
     * @SWG\Property(description="Flag indicating whether this media is retired")
     * @var int
     */
    public $retired = 0;

/**
     * @SWG\Property(description="Flag indicating whether this media has been edited and replaced with a newer file")
     * @var int
     */
    public $isEdited = 0;

/**
     * @SWG\Property(description="A MD5 checksum of the stored media file")
     * @var string
     */
    public $md5;

/**
     * @SWG\Property(description="The username of the User that owns this media")
     * @var string
     */
    public $owner;

/**
     * @SWG\Property(description="A comma separated list of groups/users with permissions to this Media")
     * @var string
     */
    public $groupsWithPermissions;

/**
     * @SWG\Property(description="A flag indicating whether this media has been released")
     * @var int
     */
    public $released = 1;

/**
     * @SWG\Property(description="An API reference")
     * @var string
     */
    public $apiRef;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Media was created"
     * )
     */
    public $createdDt;

/**
     * @var string
     * @SWG\Property(
     *  description="The datetime the Media was last modified"
     * )
     */
    public $modifiedDt;

/**
     * @var string
     * @SWG\Property(
     *  description="The option to enable the collection of Media Proof of Play statistics"
     * )
     */
    public $enableStat;

// Private
    private $unassignTags = [];
    private $requestOptions = [];
    // New file revision
    public $isSaveRequired;
    public $isRemote;

public $cloned = false;
    public $newExpiry;
    public $alwaysCopy = false;

private $widgets = [];
    private $displayGroups = [];
    private $layoutBackgroundImages = [];
    private $permissions = [];

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var TagFactory
     */
    private $tagFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;

/**
     * @var WidgetFactory
     */
    private $widgetFactory;

/**
     * @var DisplayGroupFactory
     */
    private $displayGroupFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var PlayerVersionFactory
     */
    private $playerVersionFactory;

/**
     * @var PlaylistFactory
     */
    private $playlistFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var  ScheduleFactory */
    private $scheduleFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param MediaFactory $mediaFactory
     * @param PermissionFactory $permissionFactory
     * @param TagFactory $tagFactory
     * @param PlaylistFactory $playlistFactory
     */
    public function __construct($store, $log, $config, $mediaFactory, $permissionFactory, $tagFactory, $playlistFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->config = $config;
        $this->mediaFactory = $mediaFactory;
        $this->permissionFactory = $permissionFactory;
        $this->tagFactory = $tagFactory;
        $this->playlistFactory = $playlistFactory;
    }

/**
     * Set Child Object Dependencies
     * @param LayoutFactory $layoutFactory
     * @param WidgetFactory $widgetFactory
     * @param DisplayGroupFactory $displayGroupFactory
     * @param DisplayFactory $displayFactory
     * @param ScheduleFactory $scheduleFactory
     * @param PlayerVersionFactory $playerVersionFactory
     * @return $this
     */
    public function setChildObjectDependencies($layoutFactory, $widgetFactory, $displayGroupFactory, $displayFactory, $scheduleFactory, $playerVersionFactory)
    {
        $this->layoutFactory = $layoutFactory;
        $this->widgetFactory = $widgetFactory;
        $this->displayGroupFactory  = $displayGroupFactory;
        $this->displayFactory = $displayFactory;
        $this->scheduleFactory = $scheduleFactory;
        $this->playerVersionFactory = $playerVersionFactory;
        return $this;
    }

public function __clone()
    {
        // Clear the ID's and all widget/displayGroup assignments
        $this->mediaId = null;
        $this->widgets = [];
        $this->displayGroups = [];
        $this->layoutBackgroundImages = [];
        $this->permissions = [];

// We need to do something with the name
        $this->name = sprintf(__('Copy of %s on %s'), $this->name, date('Y-m-d H:i:s'));

// Set so that when we add, we copy the existing file in the library
        $this->fileName = $this->storedAs;
        $this->storedAs = null;
        $this->cloned = true;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->mediaId;
    }

/**
     * Get Owner Id
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->ownerId = $ownerId;
    }

/**
     * @return int
     */
    private function countUsages()
    {
        $this->load(['fullInfo' => true]);

return count($this->widgets) + count($this->displayGroups) + count($this->layoutBackgroundImages);
    }

/**
     * Is this media used
     * @param int $usages threshold
     * @return bool
     */
    public function isUsed($usages = 0)
    {
        return $this->countUsages() > $usages;
    }

/**
     * Assign Tag
     * @param Tag $tag
     * @return $this
     * @throws XiboException
     */
    public function assignTag($tag)
    {
        $this->load();

if ($this->tags != [$tag]) {

if (!in_array($tag, $this->tags)) {
                $this->tags[] = $tag;
            }
        } else {
            $this->getLog()->debug('No Tags to assign');
        }

return $this;
    }

/**
     * Unassign tag
     * @param Tag $tag
     * @return $this
     * @throws XiboException
     */
    public function unassignTag($tag)
    {
        $this->load();

$this->tags = array_udiff($this->tags, [$tag], function ($a, $b) {
            /* @var Tag $a */
            /* @var Tag $b */
            return $a->tagId - $b->tagId;
        });

$this->unassignTags[] = $tag;

$this->getLog()->debug('Tags after removal %s', json_encode($this->tags));

return $this;
    }

/**
     * @param array[Tag] $tags
     */
    public function replaceTags($tags = [])
    {
        if (!is_array($this->tags) || count($this->tags) <= 0)
            $this->tags = $this->tagFactory->loadByMediaId($this->mediaId);

$this->getLog()->debug('Tags to be removed: %s', json_encode($this->unassignTags));

// Replace the arrays
            $this->tags = $tags;

$this->getLog()->debug('Tags remaining: %s', json_encode($this->tags));
        } else {
            $this->getLog()->debug('Tags were not changed');
        }
    }

/**
     * Validate
     * @param array $options
     * @throws XiboException
     */
    public function validate($options)
    {
        if (!v::stringType()->notEmpty()->validate($this->mediaType))
            throw new InvalidArgumentException(__('Unknown Module Type'), 'type');

if (!v::stringType()->notEmpty()->length(1, 100)->validate($this->name))
            throw new InvalidArgumentException(__('The name must be between 1 and 100 characters'), 'name');

// Check the naming of this item to ensure it doesn't conflict
        $params = array();
        $checkSQL = 'SELECT `name` FROM `media` WHERE `name` = :name AND userid = :userId';

if ($this->mediaId != 0) {
            $checkSQL .= ' AND mediaId <> :mediaId AND IsEdited = 0 ';
            $params['mediaId'] = $this->mediaId;
        }
        else if ($options['oldMedia'] != null && $this->name == $options['oldMedia']->name) {
            $checkSQL .= ' AND IsEdited = 0 ';
        }

$params['name'] = $this->name;
        $params['userId'] = $this->ownerId;

$result = $this->getStore()->select($checkSQL, $params);

if (count($result) > 0)
            throw new DuplicateEntityException(__('Media you own already has this name. Please choose another.'));
    }

/**
     * Load
     * @param array $options
     * @throws XiboException
     */
    public function load($options = [])
    {
        if ($this->loaded || $this->mediaId == null)
            return;

$options = array_merge([
            'deleting' => false,
            'fullInfo' => false
        ], $options);

$this->getLog()->debug('Loading Media. Options = %s', json_encode($options));

// Tags
        $this->tags = $this->tagFactory->loadByMediaId($this->mediaId);

// Are we loading for a delete? If so load the child models, unless we're a module file in which case
        // we've no need.
        if ($this->mediaType !== 'module' && ($options['deleting'] || $options['fullInfo'])) {

if ($this->widgetFactory === null)
                throw new ConfigurationException(__('Call setChildObjectDependencies before load'));

// Permissions
            $this->permissions = $this->permissionFactory->getByObjectId(get_class($this), $this->mediaId);

// Widgets
            $this->widgets = $this->widgetFactory->getByMediaId($this->mediaId);

// Layout Background Images
            $this->layoutBackgroundImages = $this->layoutFactory->getByBackgroundImageId($this->mediaId);

// Display Groups
            $this->displayGroups = $this->displayGroupFactory->getByMediaId($this->mediaId);
        }

$this->loaded = true;
    }

/**
     * Save this media
     * @param array $options
     * @throws ConfigurationException
     * @throws DuplicateEntityException
     * @throws InvalidArgumentException
     * @throws XiboException
     */
    public function save($options = [])
    {
        $this->getLog()->debug('Save for mediaId: ' . $this->mediaId);

$options = array_merge([
            'validate' => true,
            'oldMedia' => null,
            'deferred' => false,
            'saveTags' => true
        ], $options);

if ($options['validate'] && $this->mediaType != 'module')
            $this->validate($options);

// Add or edit
        if ($this->mediaId == null || $this->mediaId == 0) {
            $this->add();

// Always set force to true as we always want to save new files
            $this->isSaveRequired = true;
        }
        else {
            $this->edit();

// If the media file is invalid, then force an update (only applies to module files)
            $expires = $this->getOriginalValue('expires');
            $this->isSaveRequired = ($this->isSaveRequired || $this->valid == 0 || ($expires > 0 && $expires < time()));
        }

if ($options['deferred']) {
            $this->getLog()->debug('Media Update deferred until later');
        } else {
            $this->getLog()->debug('Media Update happening now');

// Call save file
            if ($this->isSaveRequired)
                $this->saveFile();
        }

if ($options['saveTags']) {
            // Save the tags
            if (is_array($this->tags)) {
                foreach ($this->tags as $tag) {
                    /* @var Tag $tag */
                    $tag->assignMedia($this->mediaId);
                    $tag->save();
                }
            }

// Remove unwanted ones
            if (is_array($this->unassignTags)) {
                foreach ($this->unassignTags as $tag) {
                    /* @var Tag $tag */
                    $tag->unassignMedia($this->mediaId);
                    $tag->save();
                }
            }
        }
    }

/**
     * Save Async
     * @param array $options
     * @return $this
     */
    public function saveAsync($options = [])
    {
        $options = array_merge([
            'deferred' => true,
            'requestOptions' => []
        ], $options);
        $this->requestOptions = $options['requestOptions'];
        $this->save($options);

return $this;
    }

/**
     * Delete
     * @param array $options
     * @throws \Xibo\Exception\NotFoundException
     */
    public function delete($options = [])
    {
        $options = array_merge([
            'rollback' => false
        ], $options);

if ($options['rollback']) {
            $this->deleteRecord();
            $this->deleteFile();
            return;
        }

$this->load(['deleting' => true]);

// If there is a parent, bring it back
        try {
            $parentMedia = $this->mediaFactory->getParentById($this->mediaId);
            $parentMedia->isEdited = 0;
            $parentMedia->parentId = null;
            $parentMedia->save(['validate' => false]);
        }
        catch (NotFoundException $e) {
            // This is fine, no parent
            $parentMedia = null;
        }

foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->delete();
        }

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tag->unassignMedia($this->mediaId);
            $tag->save();
        }

foreach ($this->widgets as $widget) {
            /* @var \Xibo\Entity\Widget $widget */
            $widget->unassignMedia($this->mediaId);

if ($parentMedia != null) {
                // Assign the parent media to the widget instead
                $widget->assignMedia($parentMedia->mediaId);

// Swap any audio nodes over to this new widget media assignment.
                $this->getStore()->update('
                  UPDATE `lkwidgetaudio` SET mediaId = :mediaId WHERE widgetId = :widgetId AND mediaId = :oldMediaId
                ' , [
                    'mediaId' => $parentMedia->mediaId,
                    'widgetId' => $widget->widgetId,
                    'oldMediaId' => $this->mediaId
                ]);
            } else {
                // Also delete the `lkwidgetaudio`
                $widget->unassignAudioById($this->mediaId);
            }

// This action might result in us deleting a widget (unless we are a temporary file with an expiry date)
            if ($this->mediaType != 'module' && count($widget->mediaIds) <= 0) {
                $widget->setChildObjectDepencencies($this->playlistFactory);
                $widget->delete();
            } else {
                $widget->save(['saveWidgetOptions' => false]);
            }
        }

foreach ($this->displayGroups as $displayGroup) {
            /* @var \Xibo\Entity\DisplayGroup $displayGroup */
            $displayGroup->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);
            $displayGroup->unassignMedia($this);

if ($parentMedia != null)
                $displayGroup->assignMedia($parentMedia);

$displayGroup->save(['validate' => false]);
        }

foreach ($this->layoutBackgroundImages as $layout) {
            /* @var Layout $layout */
            $layout->backgroundImageId = null;
            $layout->save(Layout::$saveOptionsMinimum);
        }

$this->deleteRecord();
        $this->deleteFile();

// Update any background images
        if ($this->mediaType == 'image' && $parentMedia != null) {
            $this->getLog()->debug('Updating layouts with the old media %d as the background image.', $this->mediaId);
            // Get all Layouts with this as the background image
            foreach ($this->layoutFactory->query(null, ['backgroundImageId' => $this->mediaId]) as $layout) {
                /* @var Layout $layout */
                $this->getLog()->debug('Found layout that needs updating. ID = %d. Setting background image id to %d', $layout->layoutId, $parentMedia->mediaId);
                $layout->backgroundImageId = $parentMedia->mediaId;
                $layout->save();
            }
        }

$this->audit($this->mediaId, 'Deleted');
    }

/**
     * Add
     * @throws ConfigurationException
     */
    private function add()
    {
        $this->mediaId = $this->getStore()->insert('
            INSERT INTO `media` (`name`, `type`, duration, originalFilename, userID, retired, moduleSystemFile, released, apiRef, valid, `createdDt`, `modifiedDt`, `enableStat`)
              VALUES (:name, :type, :duration, :originalFileName, :userId, :retired, :moduleSystemFile, :released, :apiRef, :valid, :createdDt, :modifiedDt, :enableStat)
        ', [
            'name' => $this->name,
            'type' => $this->mediaType,
            'duration' => $this->duration,
            'originalFileName' => basename($this->fileName),
            'userId' => $this->ownerId,
            'retired' => $this->retired,
            'moduleSystemFile' => (($this->moduleSystemFile) ? 1 : 0),
            'released' => $this->released,
            'apiRef' => $this->apiRef,
            'valid' => 0,
            'createdDt' => date('Y-m-d H:i:s'),
            'modifiedDt' => date('Y-m-d H:i:s'),
            'enableStat' => $this->enableStat
        ]);

}

/**
     * Edit
     */
    private function edit()
    {
        $sql = '
          UPDATE `media`
            SET `name` = :name,
                duration = :duration,
                retired = :retired,
                moduleSystemFile = :moduleSystemFile,
                editedMediaId = :editedMediaId,
                isEdited = :isEdited,
                userId = :userId,
                released = :released,
                apiRef = :apiRef,
                modifiedDt = :modifiedDt,
                `enableStat` = :enableStat,
                expires = :expires
           WHERE mediaId = :mediaId
        ';

$params = [
            'name' => $this->name,
            'duration' => $this->duration,
            'retired' => $this->retired,
            'moduleSystemFile' => $this->moduleSystemFile,
            'editedMediaId' => $this->parentId,
            'isEdited' => $this->isEdited,
            'userId' => $this->ownerId,
            'released' => $this->released,
            'apiRef' => $this->apiRef,
            'mediaId' => $this->mediaId,
            'modifiedDt' => date('Y-m-d H:i:s'),
            'enableStat' => $this->enableStat,
            'expires' => $this->expires
        ];

$this->getStore()->update($sql, $params);
    }

/**
     * Delete record
     */
    private function deleteRecord()
    {
        $this->getStore()->update('DELETE FROM media WHERE MediaID = :mediaId', ['mediaId' => $this->mediaId]);
    }

/**
     * Save File to Library
     *  works on files that are already in the File system
     * @throws ConfigurationException
     */
    public function saveFile()
    {
        $libraryFolder = $this->config->getSetting('LIBRARY_LOCATION');

// Work out the extension
        $lastPeriod = strrchr($this->fileName, '.');

// Determine the save name
        if ($lastPeriod === false) {
            $saveName = $this->mediaId;
        } else {
            $saveName = $this->mediaId . '.' . strtolower(substr($lastPeriod, 1));
        }

if(isset($this->urlDownload) && $this->urlDownload === true) {

// for upload via URL, handle cases where URL do not have specified extension in url
            // we either have a long string after lastPeriod or nothing

if (isset($this->extension) && (strlen($lastPeriod) > 3 || $lastPeriod === false)) {
                $saveName = $this->mediaId . '.' . $this->extension;
            }

$this->storedAs = $saveName;
        }

$this->getLog()->debug('saveFile for "' . $this->name . '" [' . $this->mediaId . '] with storedAs = "'
            . $this->storedAs . '", fileName = "' . $this->fileName . '" to "' . $saveName . '". Always Copy = "'
            . $this->alwaysCopy . '", Cloned = "' . $this->cloned . '"');

// If the storesAs is empty, then set it to be the moved file name
        if (empty($this->storedAs) && !$this->alwaysCopy) {

// We could be a fresh file entirely, or we could be a clone
            if ($this->cloned) {
                $this->getLog()->debug('Copying cloned file: ' . $libraryFolder . $this->fileName);
                // Copy the file into the library
                if (!@copy($libraryFolder . $this->fileName, $libraryFolder . $saveName))
                    throw new ConfigurationException(__('Problem copying file in the Library Folder'));

} else {
                $this->getLog()->debug('Moving temporary file: ' . $libraryFolder . 'temp/' . $this->fileName);
                // Move the file into the library
                if (!$this->moveFile($libraryFolder . 'temp/' . $this->fileName, $libraryFolder . $saveName))
                    throw new ConfigurationException(__('Problem moving uploaded file into the Library Folder'));
            }

// Set the storedAs
            $this->storedAs = $saveName;
        }
        else {
            // We have pre-defined where we want this to be stored
            if (empty($this->storedAs)) {
                // Assume we want to set this automatically (i.e. we are set to always copy)
                $this->storedAs = $saveName;
            }

if ($this->isRemote) {
                $this->getLog()->debug('Moving temporary file: ' . $libraryFolder . 'temp/' . $this->name);

// Move the file into the library
                if (!$this->moveFile($libraryFolder . 'temp/' . $this->name, $libraryFolder . $this->storedAs))
                    throw new ConfigurationException(__('Problem moving downloaded file into the Library Folder'));
            } else {
                $this->getLog()->debug('Copying specified file: ' . $this->fileName);

if (!@copy($this->fileName, $libraryFolder . $this->storedAs)) {
                    $this->getLog()->error('Cannot copy %s to %s', $this->fileName, $libraryFolder . $this->storedAs);
                    throw new ConfigurationException(__('Problem copying provided file into the Library Folder'));
                }
            }
        }

// Work out the MD5
        $this->md5 = md5_file($libraryFolder . $this->storedAs);
        $this->fileSize = filesize($libraryFolder . $this->storedAs);

// Set to valid
        $this->valid = 1;

// Resize image dimensions if threshold exceeds
        $this->assessDimensions();

// Update the MD5 and storedAs to suit
        $this->getStore()->update('UPDATE `media` SET md5 = :md5, fileSize = :fileSize, storedAs = :storedAs, expires = :expires, released = :released, valid = 1 WHERE mediaId = :mediaId', [
            'fileSize' => $this->fileSize,
            'md5' => $this->md5,
            'storedAs' => $this->storedAs,
            'expires' => $this->expires,
            'released' => $this->released,
            'mediaId' => $this->mediaId
        ]);
    }

private function assessDimensions()
    {

if ($this->mediaType === 'image' || ($this->mediaType === 'module' && $this->moduleSystemFile === 0)) {

$libraryFolder = $this->config->getSetting('LIBRARY_LOCATION');
            $filePath = $libraryFolder . $this->storedAs;
            list($imgWidth, $imgHeight) = @getimagesize($filePath);

$resizeThreshold = $this->config->getSetting('DEFAULT_RESIZE_THRESHOLD');
            $resizeLimit = $this->config->getSetting('DEFAULT_RESIZE_LIMIT');

// Media released set to 0 for large size images
            // if image size is greater than Resize Limit then we flag that image as too big
            if ($resizeLimit > 0 && ($imgWidth > $resizeLimit || $imgHeight > $resizeLimit)) {
                $this->released = 2;
                $this->getLog()->debug('Image size is too big. MediaId '. $this->mediaId);

} elseif ($resizeThreshold > 0) {
                if ($imgWidth > $imgHeight) { // 'landscape';

if ($imgWidth <= $resizeThreshold) {
                        $this->released = 1;
                    } else {
                        if ($resizeThreshold > 0) {
                            $this->released = 0;
                            $this->getLog()->debug('Image exceeded threshold, released set to 0. MediaId '. $this->mediaId);
                        }
                    }
                } else { // 'portrait';

if ($imgHeight <= $resizeThreshold) {
                        $this->released = 1;
                    } else {
                        if ($resizeThreshold > 0) {
                            $this->released = 0;
                            $this->getLog()->debug('Image exceeded threshold, released set to 0. MediaId '. $this->mediaId);
                        }
                    }
                }
            }

}
    }

/**
     * Release an image from image processing
     * @param $md5
     * @param $fileSize
     */
    public function release($md5, $fileSize)
    {
        // Update the MD5 and fileSize
        $this->getStore()->update('UPDATE `media` SET md5 = :md5, fileSize = :fileSize, released = :released, modifiedDt = :modifiedDt WHERE mediaId = :mediaId', [
            'fileSize' => $fileSize,
            'md5' => $md5,
            'released' => 1,
            'mediaId' => $this->mediaId,
            'modifiedDt' => date('Y-m-d H:i:s')
        ]);
        $this->getLog()->debug('Updating image md5 and fileSize. MediaId '. $this->mediaId);

}

/**
     * Delete a Library File
     */
    private function deleteFile()
    {
        // Make sure storedAs isn't null
        if ($this->storedAs == null) {
            $this->getLog()->error('Deleting media [%s] with empty stored as. Skipping library file delete.', $this->name);
            return;
        }

// Library location
        $libraryLocation = $this->config->getSetting("LIBRARY_LOCATION");

// 3 things to check for..
        // the actual file, the thumbnail, the background
        if (file_exists($libraryLocation . $this->storedAs))
            unlink($libraryLocation . $this->storedAs);

if (file_exists($libraryLocation . 'tn_' . $this->storedAs))
            unlink($libraryLocation . 'tn_' . $this->storedAs);
    }

/**
     * Workaround for moving files across file systems
     * @param $from
     * @param $to
     * @return bool
     */
    private function moveFile($from, $to)
    {
        // Try to move the file first
        $moved = rename($from, $to);

if (!$moved) {
            $this->getLog()->info('Cannot move file: ' . $from . ' to ' . $to . ', will try and copy/delete instead.');

// Copy
            $moved = copy($from, $to);

// Delete
            if (!@unlink($from)) {
                $this->getLog()->error('Cannot delete file: ' . $from . ' after copying to ' . $to);
            }
        }

return $moved;
    }

/**
     * Download URL
     * @return string
     */
    public function downloadUrl()
    {
        return $this->fileName;
    }

/**
     * Download Sink
     * @return string
     */
    public function downloadSink()
    {
        return $this->config->getSetting('LIBRARY_LOCATION') . 'temp' . DIRECTORY_SEPARATOR . $this->name;
    }

/**
     * Get optional options for downloading media files
     * @return array
     */
    public function downloadRequestOptions()
    {
        return $this->requestOptions;
    }
}PK�������qY�?	;�#���#����Application.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Application.php)
 */

namespace Xibo\Entity;
use League\OAuth2\Server\Util\SecureKey;
use Xibo\Factory\ApplicationRedirectUriFactory;
use Xibo\Factory\ApplicationScopeFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Application
 * @package Xibo\Entity
 *
 * @SWG\Definition
 */
class Application implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="Application Key"
     * )
     * @var string
     */
    public $key;

/**
     * @SWG\Property(
     *  description="Private Secret Key"
     * )
     * @var string
     */
    public $secret;

/**
     * @SWG\Property(
     *  description="Application Name"
     * )
     * @var string
     */
    public $name;
    
    /**
     * @SWG\Property(
     *  description="Application Owner"
     * )
     * @var string
     */
    public $owner;

/**
     * @SWG\Property(
     *  description="Application Session Expiry"
     * )
     * @var int
     */
    public $expires;

/**
     * @SWG\Property(
     *  description="The Owner of this Application"
     * )
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="Flag indicating whether to allow the authorizationCode Grant Type")
     * @var int
     */
    public $authCode = 0;

/**
     * @SWG\Property(description="Flag indicating whether to allow the clientCredentials Grant Type")
     * @var int
     */
    public $clientCredentials = 0;

/**
     * @var array[ApplicationRedirectUri]
     */
    public $redirectUris = [];

/**
     * @var array[ApplicationScope]
     */
    public $scopes = [];

/**
     * @var ApplicationRedirectUriFactory
     */
    private $applicationRedirectUriFactory;

/** @var  ApplicationScopeFactory */
    private $applicationScopeFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ApplicationRedirectUriFactory $applicationRedirectUriFactory
     * @param ApplicationScopeFactory $applicationScopeFactory
     */
    public function __construct($store, $log, $applicationRedirectUriFactory, $applicationScopeFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->applicationRedirectUriFactory = $applicationRedirectUriFactory;
        $this->applicationScopeFactory = $applicationScopeFactory;
    }

/**
     * @param ApplicationRedirectUri $redirectUri
     */
    public function assignRedirectUri($redirectUri)
    {
        $this->load();

// Assert client id
        $redirectUri->clientId = $this->key;

if (!in_array($redirectUri, $this->redirectUris))
            $this->redirectUris[] = $redirectUri;
    }

/**
     * Unassign RedirectUri
     * @param ApplicationRedirectUri $redirectUri
     */
    public function unassignRedirectUri($redirectUri)
    {
        $this->load();

$this->redirectUris = array_udiff($this->redirectUris, [$redirectUri], function($a, $b) {
            /**
             * @var ApplicationRedirectUri $a
             * @var ApplicationRedirectUri $b
             */
            return $a->getId() - $b->getId();
        });
    }

/**
     * @param ApplicationScope $scope
     */
    public function assignScope($scope) {
        $this->load();

if (!in_array($scope, $this->scopes))
            $this->scopes[] = $scope;
    }

/**
     * @param ApplicationScope $scope
     */
    public function unassignScope($scope) {
        $this->load();

$this->scopes = array_udiff($this->scopes, [$scope], function($a, $b) {
            /**
             * @var ApplicationScope $a
             * @var ApplicationScope $b
             */
            return $a->getId() - $b->getId();
        });
    }

/**
     * Load
     */
    public function load()
    {
        if ($this->loaded)
            return;

$this->redirectUris = $this->applicationRedirectUriFactory->getByClientId($this->key);

// Get scopes
        $this->scopes = $this->applicationScopeFactory->getByClientId($this->key);

$this->loaded = true;
    }

public function save()
    {
        if ($this->key == null || $this->key == '')
            $this->add();
        else
            $this->edit();

$this->getLog()->debug('Saving redirect uris: %s', json_encode($this->redirectUris));

foreach ($this->redirectUris as $redirectUri) {
            /* @var \Xibo\Entity\ApplicationRedirectUri $redirectUri */
            $redirectUri->save();
        }

$this->manageScopeAssignments();
    }

public function delete()
    {
        $this->load();

foreach ($this->redirectUris as $redirectUri) {
            /* @var \Xibo\Entity\ApplicationRedirectUri $redirectUri */
            $redirectUri->delete();
        }

// Clear out everything owned by this client
        $this->deleteTokens();
        $this->getStore()->update('DELETE FROM `oauth_session_scopes` WHERE id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id)', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_sessions` WHERE `client_id` = :id', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_client_scopes` WHERE `clientId` = :id', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_clients` WHERE `id` = :id', ['id' => $this->key]);
    }

public function resetKeys()
    {
        $this->secret = SecureKey::generate(254);
        $this->deleteTokens();
    }

private function deleteTokens()
    {
        $this->getStore()->update('DELETE FROM `oauth_access_token_scopes` WHERE access_token IN (SELECT access_token FROM `oauth_access_tokens` WHERE session_id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id))', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_refresh_tokens` WHERE access_token IN (SELECT access_token FROM `oauth_access_tokens` WHERE session_id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id))', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_access_tokens` WHERE session_id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id)', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_auth_code_scopes` WHERE auth_code IN (SELECT auth_code FROM `oauth_auth_codes` WHERE session_id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id))', ['id' => $this->key]);
        $this->getStore()->update('DELETE FROM `oauth_auth_codes` WHERE session_id IN (SELECT session_id FROM `oauth_sessions` WHERE `client_id` = :id)', ['id' => $this->key]);
    }

private function add()
    {
        $this->key = SecureKey::generate();

// Simple Insert for now
        $this->getStore()->insert('
            INSERT INTO `oauth_clients` (`id`, `secret`, `name`, `userId`, `authCode`, `clientCredentials`)
              VALUES (:id, :secret, :name, :userId, :authCode, :clientCredentials)
        ', [
            'id' => $this->key,
            'secret' => $this->secret,
            'name' => $this->name,
            'userId' => $this->userId,
            'authCode' => $this->authCode,
            'clientCredentials' => $this->clientCredentials
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
            UPDATE `oauth_clients` SET
              `id` = :id,
              `secret` = :secret,
              `name` = :name,
              `userId` = :userId,
              `authCode` = :authCode,
              `clientCredentials` = :clientCredentials
             WHERE `id` = :id
        ', [
            'id' => $this->key,
            'secret' => $this->secret,
            'name' => $this->name,
            'userId' => $this->userId,
            'authCode' => $this->authCode,
            'clientCredentials' => $this->clientCredentials
        ]);
    }

/**
     * Compare the original assignments with the current assignments and delete any that are missing, add any new ones
     */
    private function manageScopeAssignments() {

$i = 0;
        $params = ['clientId' => $this->key];
        $unassignIn = '';

foreach ($this->scopes as $link) {
            $this->getStore()->update('
              INSERT INTO `oauth_client_scopes` (clientId, scopeId) VALUES (:clientId, :scopeId)
              ON DUPLICATE KEY UPDATE scopeId = scopeId', [
                'clientId' => $this->key,
                'scopeId' => $link->id
            ]);

$i++;
            $unassignIn .= ',:scopeId' . $i;
            $params['scopeId' . $i] = $link->id;
        }

// Unlink any NOT in the collection
        $sql = 'DELETE FROM `oauth_client_scopes` WHERE clientId = :clientId AND scopeId NOT IN (\'0\'' . $unassignIn . ')';

$this->getStore()->update($sql, $params);
    }
}PK�������qY�"��L���L�����Schedule.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Jenssegers\Date\Date;
use Respect\Validation\Validator as v;
use Stash\Interfaces\PoolInterface;
use Xibo\Exception\ConfigurationException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\CampaignFactory;
use Xibo\Factory\DayPartFactory;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\ScheduleExclusionFactory;
use Xibo\Factory\ScheduleReminderFactory;
use Xibo\Factory\UserFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Schedule
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Schedule implements \JsonSerializable
{
    use EntityTrait;

public static $LAYOUT_EVENT = 1;
    public static $COMMAND_EVENT = 2;
    public static $OVERLAY_EVENT = 3;
    public static $INTERRUPT_EVENT = 4;
    public static $CAMPAIGN_EVENT = 5;
    public static $DATE_MIN = 0;
    public static $DATE_MAX = 2147483647;

/**
     * @SWG\Property(
     *  description="The ID of this Event"
     * )
     * @var int
     */
    public $eventId;

/**
     * @SWG\Property(
     *  description="The Event Type ID"
     * )
     * @var int
     */
    public $eventTypeId;

/**
     * @SWG\Property(
     *  description="The CampaignID this event is for"
     * )
     * @var int
     */
    public $campaignId;

/**
     * @SWG\Property(
     *  description="The CommandId this event is for"
     * )
     * @var int
     */
    public $commandId;

/**
     * @SWG\Property(
     *  description="Display Groups assigned to this Scheduled Event.",
     *  type="array",
     *  @SWG\Items(ref="#/definitions/DisplayGroup")
     * )
     * @var DisplayGroup[]
     */
    public $displayGroups = [];

/**
     * @SWG\Property(
     *  description="Schedule Reminders assigned to this Scheduled Event.",
     *  type="array",
     *  @SWG\Items(ref="#/definitions/ScheduleReminder")
     * )
     * @var ScheduleReminder[]
     */
    public $scheduleReminders = [];

/**
     * @SWG\Property(
     *  description="The userId that owns this event."
     * )
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(
     *  description="A Unix timestamp representing the from date of this event in CMS time."
     * )
     * @var int
     */
    public $fromDt;

/**
     * @SWG\Property(
     *  description="A Unix timestamp representing the to date of this event in CMS time."
     * )
     * @var int
     */
    public $toDt;

/**
     * @SWG\Property(
     *  description="Integer indicating the event priority."
     * )
     * @var int
     */
    public $isPriority;

/**
     * @SWG\Property(
     *  description="The display order for this event."
     * )
     * @var int
     */
    public $displayOrder;

/**
     * @SWG\Property(
     *  description="If this event recurs when what is the recurrence period.",
     *  enum={"None", "Minute", "Hour", "Day", "Week", "Month", "Year"}
     * )
     * @var string
     */
    public $recurrenceType;

/**
     * @SWG\Property(
     *  description="If this event recurs when what is the recurrence frequency.",
     * )
     * @var int
     */
    public $recurrenceDetail;

/**
     * @SWG\Property(
     *  description="A Unix timestamp indicating the end time of the recurring events."
     * )
     * @var int
     */
    public $recurrenceRange;

/**
     * @SWG\Property(description="Recurrence repeats on days - 0 to 7 where 0 is a monday")
     * @var string
     */
    public $recurrenceRepeatsOn;

/**
     * @SWG\Property(description="Recurrence monthly repeats on - 0 is day of month, 1 is weekday of week")
     * @var int
     */
    public $recurrenceMonthlyRepeatsOn;

/**
     * @SWG\Property(
     *  description="The Campaign/Layout Name",
     *  readOnly=true
     * )
     * @var string
     */
    public $campaign;

/**
     * @SWG\Property(
     *  description="The Command Name",
     *  readOnly=true
     * )
     * @var string
     */
    public $command;

/**
     * @SWG\Property(
     *  description="The Day Part Id"
     * )
     * @var int
     */
    public $dayPartId;

/**
     * @SWG\Property(description="Is this event an always on event?")
     * @var int
     */
    public $isAlways;

/**
     * @SWG\Property(description="Does this event have custom from/to date times?")
     * @var int
     */
    public $isCustom;

/**
     * Last Recurrence Watermark
     * @var int
     */
    public $lastRecurrenceWatermark;

/**
     * @SWG\Property(description="Flag indicating whether the event should be synchronised across displays")
     * @var int
     */
    public $syncEvent = 0;

/**
     * @SWG\Property(description="Flag indicating whether the event will sync to the Display timezone")
     * @var int
     */
    public $syncTimezone;

/**
     * @SWG\Property(description="Seconds (0-3600) of each full hour that is scheduled that this Layout should occupy")
     * @var int
     */
    public $shareOfVoice;

/**
     * @SWG\Property(description="Flag (0-1), whether this event is using Geo Location")
     * @var int
     */
    public $isGeoAware;

/**
     * @SWG\Property(description="Geo JSON representing the area of this event")
     * @var string
     */
    public $geoLocation;

/**
     * @var ScheduleEvent[]
     */
    private $scheduleEvents = [];

/**
     * @var ConfigServiceInterface
     */
    private $config;

/** @var  DateServiceInterface */
    private $dateService;

/** @var  PoolInterface */
    private $pool;

/**
     * @var DisplayGroupFactory
     */
    private $displayGroupFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var  DayPartFactory */
    private $dayPartFactory;

/** @var  CampaignFactory */
    private $campaignFactory;

/** @var  ScheduleReminderFactory */
    private $scheduleReminderFactory;

/** @var  ScheduleExclusionFactory */
    private $scheduleExclusionFactory;

/**
     * @var UserFactory
     */
    private $userFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param PoolInterface $pool
     * @param DateServiceInterface $date
     * @param DisplayGroupFactory $displayGroupFactory
     * @param DayPartFactory $dayPartFactory
     * @param UserFactory $userFactory
     * @param ScheduleReminderFactory $scheduleReminderFactory
     * @param ScheduleExclusionFactory $scheduleExclusionFactory
     */
    public function __construct($store, $log, $config, $pool, $date, $displayGroupFactory, $dayPartFactory, $userFactory, $scheduleReminderFactory, $scheduleExclusionFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->config = $config;
        $this->pool = $pool;
        $this->dateService = $date;
        $this->displayGroupFactory = $displayGroupFactory;
        $this->dayPartFactory = $dayPartFactory;
        $this->userFactory = $userFactory;
        $this->scheduleReminderFactory = $scheduleReminderFactory;
        $this->scheduleExclusionFactory = $scheduleExclusionFactory;

$this->excludeProperty('lastRecurrenceWatermark');
    }

/**
     * @param CampaignFactory $campaignFactory
     * @return $this
     */
    public function setCampaignFactory($campaignFactory)
    {
        $this->campaignFactory = $campaignFactory;
        return $this;
    }

public function __clone()
    {
        $this->eventId = null;
    }

/**
     * @param DisplayFactory $displayFactory
     * @return $this
     */
    public function setDisplayFactory($displayFactory)
    {
        $this->displayFactory = $displayFactory;
        return $this;
    }

/**
     * @param DateServiceInterface $dateService
     * @deprecated dateService is set by the factory
     * @return $this
     */
    public function setDateService($dateService)
    {
        $this->dateService = $dateService;
        return $this;
    }

/**
     * @return DateServiceInterface
     * @throws ConfigurationException
     */
    private function getDate()
    {
        if ($this->dateService == null)
            throw new ConfigurationException('Application Error: Date Service is not set on Schedule Entity');

return $this->dateService;
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->eventId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->userId = $ownerId;
    }

/**
     * Are the provided dates within the schedule look ahead
     * @return bool
     * @throws XiboException
     */
    private function inScheduleLookAhead()
    {
        if ($this->isAlwaysDayPart())
            return true;

// From Date and To Date are in UNIX format
        $currentDate = $this->getDate()->parse();
        $rfLookAhead = clone $currentDate;
        $rfLookAhead->addSeconds(intval($this->config->getSetting('REQUIRED_FILES_LOOKAHEAD')));

// Dial current date back to the start of the day
        $currentDate->startOfDay();

// Test dates
        if ($this->recurrenceType != '') {
            // A recurring event
            $this->getLog()->debug('Checking look ahead based on recurrence');
            // we should check whether the event from date is before the lookahead (i.e. the event has recurred once)
            // we should also check whether the recurrence range is still valid (i.e. we've not stopped recurring and we don't recur forever)
            return (
                $this->fromDt <= $rfLookAhead->format('U')
                && ($this->recurrenceRange == 0 || $this->recurrenceRange > $currentDate->format('U'))
            );
        } else if (!$this->isCustomDayPart() || $this->eventTypeId == self::$COMMAND_EVENT) {
            // Day parting event (non recurring) or command event
            // only test the from date.
            $this->getLog()->debug('Checking look ahead based from date ' . $currentDate->toRssString());
            return ($this->fromDt >= $currentDate->format('U') && $this->fromDt <= $rfLookAhead->format('U'));
        } else {
            // Compare the event dates
            $this->getLog()->debug('Checking look ahead based event dates ' . $currentDate->toRssString() . ' / ' . $rfLookAhead->toRssString());
            return ($this->fromDt <= $rfLookAhead->format('U') && $this->toDt >= $currentDate->format('U'));
        }
    }

/**
     * Load
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadScheduleReminders' => false
        ], $options);

// If we are already loaded, then don't do it again
        if ($this->loaded || $this->eventId == null || $this->eventId == 0)
            return;

$this->displayGroups = $this->displayGroupFactory->getByEventId($this->eventId);

// Load schedule reminders
        if ($options['loadScheduleReminders']) {
            $this->scheduleReminders = $this->scheduleReminderFactory->query(null, ['eventId'=> $this->eventId]);
        }

// Set the original values now that we're loaded.
        $this->setOriginals();

// We are fully loaded
        $this->loaded = true;
    }

/**
     * Assign DisplayGroup
     * @param DisplayGroup $displayGroup
     */
    public function assignDisplayGroup($displayGroup)
    {
        $this->load();

if (!in_array($displayGroup, $this->displayGroups))
            $this->displayGroups[] = $displayGroup;
    }

/**
     * Unassign DisplayGroup
     * @param DisplayGroup $displayGroup
     */
    public function unassignDisplayGroup($displayGroup)
    {
        $this->load();

$this->displayGroups = array_udiff($this->displayGroups, [$displayGroup], function ($a, $b) {
            /**
             * @var DisplayGroup $a
             * @var DisplayGroup $b
             */
            return $a->getId() - $b->getId();
        });
    }

/**
     * Validate
     * @throws XiboException
     */
    public function validate()
    {
        if (count($this->displayGroups) <= 0) {
            throw new InvalidArgumentException(__('No display groups selected'), 'displayGroups');
        }

$this->getLog()->debug('EventTypeId: ' . $this->eventTypeId
            . '. DayPartId: ' . $this->dayPartId
            . ', CampaignId: ' . $this->campaignId
            . ', CommandId: ' . $this->commandId);

if ($this->eventTypeId == Schedule::$LAYOUT_EVENT ||
            $this->eventTypeId == Schedule::$CAMPAIGN_EVENT ||
            $this->eventTypeId == Schedule::$OVERLAY_EVENT ||
            $this->eventTypeId == Schedule::$INTERRUPT_EVENT
        ) {
            // Validate layout
            if (!v::intType()->notEmpty()->validate($this->campaignId))
                throw new InvalidArgumentException(__('Please select a Campaign/Layout for this event.'), 'campaignId');

if ($this->isCustomDayPart()) {
                // validate the dates
                if ($this->toDt <= $this->fromDt)
                    throw new InvalidArgumentException(__('Can not have an end time earlier than your start time'), 'start/end');
            }

$this->commandId = null;

// additional validation for Interrupt Layout event type
            if ($this->eventTypeId == Schedule::$INTERRUPT_EVENT) {

// Hack : If this is an interrupt, check that the column is a SMALLINT and if it isn't alter the table
                $sql = 'SELECT DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = :table_name AND COLUMN_NAME = :column_name';
                $params = ['table_name' => 'schedule', 'column_name' => 'shareOfVoice' ];
                $results = $this->store->select($sql, $params);

if (count($results) > 0) {
                    $dataType = $results[0]['DATA_TYPE'];

if ($dataType !== 'smallint') {
                        $this->store->update('ALTER TABLE `schedule` MODIFY `shareOfVoice` SMALLINT', []);

// convert any existing interrupt schedules?
                        $this->store->update('UPDATE `schedule` SET `shareOfVoice` = 3600 * (shareOfVoice / 100) WHERE shareOfVoice > 0', []);
                    }
                }

if (!v::intType()->notEmpty()->min(0)->max(3600)->validate($this->shareOfVoice)) {
                    throw new InvalidArgumentException(__('Share of Voice must be a whole number between 0 and 3600'), 'shareOfVoice');
                }
            }

} else if ($this->eventTypeId == Schedule::$COMMAND_EVENT) {
            // Validate command
            if (!v::intType()->notEmpty()->validate($this->commandId))
                throw new InvalidArgumentException(__('Please select a Command for this event.'), 'command');

$this->campaignId = null;
            $this->toDt = null;

} else {
            // No event type selected
            throw new InvalidArgumentException(__('Please select the Event Type'), 'eventTypeId');
        }

// Make sure we have a sensible recurrence setting
        if (!$this->isCustomDayPart() && ($this->recurrenceType == 'Minute' || $this->recurrenceType == 'Hour'))
            throw new InvalidArgumentException(__('Repeats selection is invalid for Always or Daypart events'), 'recurrencyType');

// Check display order is positive
        if ($this->displayOrder < 0)
            throw new InvalidArgumentException(__('Display Order must be 0 or a positive number'), 'displayOrder');

// Check priority is positive
        if ($this->isPriority < 0)
            throw new InvalidArgumentException(__('Priority must be 0 or a positive number'), 'isPriority');

// Check recurrenceDetail every is positive
        if ($this->recurrenceType != '' && ($this->recurrenceDetail === null || $this->recurrenceDetail <= 0))
            throw new InvalidArgumentException(__('Repeat every must be a positive number'), 'recurrenceDetail');
    }

/**
     * Save
     * @param array $options
     * @throws XiboException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'audit' => true,
            'deleteOrphaned' => false,
            'notify' => true
        ], $options);

if ($options['validate'])
            $this->validate();

// Handle "always" day parts
        if ($this->isAlwaysDayPart()) {
            $this->fromDt = self::$DATE_MIN;
            $this->toDt = self::$DATE_MAX;
        }

if ($this->eventId == null || $this->eventId == 0) {
            $this->add();
            $auditMessage = 'Added';
            $this->loaded = true;
            $isEdit = false;
        }
        else {
            // If this save action means there aren't any display groups assigned
            // and if we're set to deleteOrphaned, then delete
            if ($options['deleteOrphaned'] && count($this->displayGroups) <= 0) {
                $this->delete();
                return;
            } else {
                $this->edit();
                $auditMessage = 'Saved';
            }
            $isEdit = true;
        }

// Manage display assignments
        if ($this->loaded) {
            // Manage assignments
            $this->manageAssignments($isEdit && $options['notify']);
        }

// Notify
        if ($options['notify']) {
            // Only if the schedule effects the immediate future - i.e. within the RF Look Ahead
            if ($this->inScheduleLookAhead()) {
                $this->getLog()->debug('Schedule changing is within the schedule look ahead, will notify ' . count($this->displayGroups) . ' display groups');
                foreach ($this->displayGroups as $displayGroup) {
                    /* @var DisplayGroup $displayGroup */
                    $this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByDisplayGroupId($displayGroup->displayGroupId);
                }
            } else {
                $this->getLog()->debug('Schedule changing is not within the schedule look ahead');
            }
        }

if ($options['audit'])
            $this->audit($this->getId(), $auditMessage);

// Drop the cache for this event
        $this->dropEventCache();
    }

/**
     * Delete this Schedule Event
     */
    public function delete()
    {
        $this->load();

// Notify display groups
        $notify = $this->displayGroups;

// Delete display group assignments
        $this->displayGroups = [];
        $this->unlinkDisplayGroups();

// Delete schedule exclusions
        $scheduleExclusions = $this->scheduleExclusionFactory->query(null, ['eventId' => $this->eventId]);
        foreach ($scheduleExclusions as $exclusion) {
            $exclusion->delete();
        }

// Delete schedule reminders
        if ($this->scheduleReminderFactory !== null) {
            $scheduleReminders = $this->scheduleReminderFactory->query(null, ['eventId' => $this->eventId]);

foreach ($scheduleReminders as $reminder) {
                $reminder->delete();
            }
        }

// Delete the event itself
        $this->getStore()->update('DELETE FROM `schedule` WHERE eventId = :eventId', ['eventId' => $this->eventId]);

// Notify
        // Only if the schedule effects the immediate future - i.e. within the RF Look Ahead
        if ($this->inScheduleLookAhead() && $this->displayFactory !== null) {
            $this->getLog()->debug('Schedule changing is within the schedule look ahead, will notify ' . count($notify) . ' display groups');
            foreach ($notify as $displayGroup) {
                /* @var DisplayGroup $displayGroup */
                $this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByDisplayGroupId($displayGroup->displayGroupId);
            }
        } else if ($this->displayFactory === null) {
            $this->getLog()->info('Notify disabled, dependencies not set');
        }

// Drop the cache for this event
        $this->dropEventCache();

// Audit
        $this->audit($this->getId(), 'Deleted', $this->toArray());
    }

/**
     * Add
     */
    private function add()
    {
        $this->eventId = $this->getStore()->insert('
          INSERT INTO `schedule` (eventTypeId, CampaignId, commandId, userID, is_priority, FromDT, ToDT, DisplayOrder, recurrence_type, recurrence_detail, recurrence_range, `recurrenceRepeatsOn`, `recurrenceMonthlyRepeatsOn`, `dayPartId`, `syncTimezone`, `syncEvent`, `shareOfVoice`, `isGeoAware`, `geoLocation`)
            VALUES (:eventTypeId, :campaignId, :commandId, :userId, :isPriority, :fromDt, :toDt, :displayOrder, :recurrenceType, :recurrenceDetail, :recurrenceRange, :recurrenceRepeatsOn, :recurrenceMonthlyRepeatsOn, :dayPartId, :syncTimezone, :syncEvent, :shareOfVoice, :isGeoAware, :geoLocation)
        ', [
            'eventTypeId' => $this->eventTypeId,
            'campaignId' => $this->campaignId,
            'commandId' => $this->commandId,
            'userId' => $this->userId,
            'isPriority' => $this->isPriority,
            'fromDt' => $this->fromDt,
            'toDt' => $this->toDt,
            'displayOrder' => $this->displayOrder,
            'recurrenceType' => $this->recurrenceType,
            'recurrenceDetail' => $this->recurrenceDetail,
            'recurrenceRange' => $this->recurrenceRange,
            'recurrenceRepeatsOn' => $this->recurrenceRepeatsOn,
            'recurrenceMonthlyRepeatsOn' => ($this->recurrenceMonthlyRepeatsOn == null) ? 0 : $this->recurrenceMonthlyRepeatsOn,
            'dayPartId' => $this->dayPartId,
            'syncTimezone' => $this->syncTimezone,
            'syncEvent' => $this->syncEvent,
            'shareOfVoice' => $this->shareOfVoice,
            'isGeoAware' => $this->isGeoAware,
            'geoLocation' => $this->geoLocation
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $this->getStore()->update('
          UPDATE `schedule` SET
            eventTypeId = :eventTypeId,
            campaignId = :campaignId,
            commandId = :commandId,
            is_priority = :isPriority,
            userId = :userId,
            fromDt = :fromDt,
            toDt = :toDt,
            displayOrder = :displayOrder,
            recurrence_type = :recurrenceType,
            recurrence_detail = :recurrenceDetail,
            recurrence_range = :recurrenceRange,
            `recurrenceRepeatsOn` = :recurrenceRepeatsOn,
            `recurrenceMonthlyRepeatsOn` = :recurrenceMonthlyRepeatsOn,
            `dayPartId` = :dayPartId,
            `syncTimezone` = :syncTimezone,
            `syncEvent` = :syncEvent,
            `shareOfVoice` = :shareOfVoice,
            `isGeoAware` = :isGeoAware,
            `geoLocation` = :geoLocation
          WHERE eventId = :eventId
        ', [
            'eventTypeId' => $this->eventTypeId,
            'campaignId' => ($this->campaignId !== 0) ? $this->campaignId : null,
            'commandId' => $this->commandId,
            'userId' => $this->userId,
            'isPriority' => $this->isPriority,
            'fromDt' => $this->fromDt,
            'toDt' => $this->toDt,
            'displayOrder' => $this->displayOrder,
            'recurrenceType' => $this->recurrenceType,
            'recurrenceDetail' => $this->recurrenceDetail,
            'recurrenceRange' => $this->recurrenceRange,
            'recurrenceRepeatsOn' => $this->recurrenceRepeatsOn,
            'recurrenceMonthlyRepeatsOn' => $this->recurrenceMonthlyRepeatsOn,
            'dayPartId' => $this->dayPartId,
            'syncTimezone' => $this->syncTimezone,
            'syncEvent' => $this->syncEvent,
            'shareOfVoice' => $this->shareOfVoice,
            'isGeoAware' => $this->isGeoAware,
            'geoLocation' => $this->geoLocation,
            'eventId' => $this->eventId
        ]);
    }

/**
     * Get events between the provided dates.
     * @param Date $fromDt
     * @param Date $toDt
     * @return ScheduleEvent[]
     * @throws XiboException
     */
    public function getEvents($fromDt, $toDt)
    {
        // Events scheduled "always" will return one event
        if ($this->isAlwaysDayPart()) {
            // Create events with min/max dates
            $this->addDetail(Schedule::$DATE_MIN, Schedule::$DATE_MAX);
            return $this->scheduleEvents;
        }

// Copy the dates as we are going to be operating on them.
        $fromDt = $fromDt->copy();
        $toDt = $toDt->copy();

if ($this->pool == null)
            throw new ConfigurationException(__('Cache pool not available'));

if ($this->eventId == null)
            throw new InvalidArgumentException(__('Unable to generate schedule, unknown event'), 'eventId');

// What if we are requesting a single point in time?
        if ($fromDt == $toDt) {
            $this->log->debug('Requesting event for a single point in time: ' . $this->getDate()->getLocalDate($fromDt));
        }

$events = [];
        $fromTimeStamp = $fromDt->format('U');
        $toTimeStamp = $toDt->format('U');

// Rewind the from date to the start of the month
        $fromDt->startOfMonth();

if ($fromDt == $toDt) {
            $this->log->debug('From and To Dates are the same after rewinding 1 month, the date is the 1st of the month, adding a month to toDate.');
            $toDt->addMonth();
        }

// Load the dates into a date object for parsing
        $eventStart = $this->getDate()->parse($this->fromDt, 'U');
        $eventEnd = ($this->toDt == null) ? $eventStart->copy() : $this->getDate()->parse($this->toDt, 'U');

// Does the original event go over the month boundary?
        if ($eventStart->month !== $eventEnd->month) {
            // We expect some residual events to spill out into the month we are generating
            // wind back the generate from date
            $fromDt->subMonth();

$this->getLog()->debug('Expecting events from the prior month to spill over into this one, pulled back the generate from dt to ' . $fromDt->toRssString());
        } else {
            $this->getLog()->debug('The main event has a start and end date within the month, no need to pull it in from the prior month. [eventId:' . $this->eventId . ']');
        }

// Keep a cache of schedule exclusions, so we look them up by eventId only one time per event
        $scheduleExclusions = $this->scheduleExclusionFactory->query(null, ['eventId' => $this->eventId]);

// Request month cache
        while ($fromDt < $toDt) {

// Empty scheduleEvents as we are looping through each month
            // we dont want to save previous month events
            $this->scheduleEvents = [];

// Events for the month.
            $this->generateMonth($fromDt, $eventStart, $eventEnd);

$this->getLog()->debug('Filtering Events: ' . json_encode($this->scheduleEvents, JSON_PRETTY_PRINT) . '. fromTimeStamp: ' . $fromTimeStamp . ', toTimeStamp: ' . $toTimeStamp);

foreach ($this->scheduleEvents as $scheduleEvent) {

// Find the excluded recurring events
                $exclude = false;
                foreach ($scheduleExclusions as $exclusion) {
                    if ($scheduleEvent->fromDt == $exclusion->fromDt &&
                        $scheduleEvent->toDt == $exclusion->toDt) {
                        $exclude = true;
                        continue;
                    }
                }

if ($exclude) {
                    continue;
                }

if (in_array($scheduleEvent, $events)) {
                    continue;
                }

if ($scheduleEvent->toDt == null) {
                    if ($scheduleEvent->fromDt >= $fromTimeStamp && $scheduleEvent->toDt < $toTimeStamp) {
                        $events[] = $scheduleEvent;
                    }
                } else {
                    if ($scheduleEvent->fromDt <= $toTimeStamp && $scheduleEvent->toDt > $fromTimeStamp) {
                        $events[] = $scheduleEvent;
                    }
                }
            }

// Move the month forwards
            $fromDt->addMonth();
        }

// Clear our cache of schedule exclusions
        $scheduleExclusions = null;

$this->getLog()->debug('Filtered ' . count($this->scheduleEvents) . ' to ' . count($events) . ', events: ' . json_encode($events, JSON_PRETTY_PRINT));

return $events;
    }

/**
     * Generate Instances
     * @param Date $generateFromDt
     * @param Date $start
     * @param Date $end
     * @throws XiboException
     */
    private function generateMonth($generateFromDt, $start, $end)
    {
        // Operate on copies of the dates passed.
        $start = $start->copy();
        $end = $end->copy();
        $generateFromDt->copy()->startOfMonth();
        $generateToDt = $generateFromDt->copy()->addMonth();

$this->getLog()->debug('Request for schedule events on eventId ' . $this->eventId
            . ' from: ' . $this->getDate()->getLocalDate($generateFromDt)
            . ' to: ' . $this->getDate()->getLocalDate($generateToDt)
            . ' [eventId:' . $this->eventId . ']'
        );

// If we are a daypart event, look up the start/end times for the event
        $this->calculateDayPartTimes($start, $end);

// Does the original event fall into this window?
        if ($start <= $generateToDt && $end > $generateFromDt) {
            // Add the detail for the main event (this is the event that originally triggered the generation)
            $this->getLog()->debug('Adding original event: ' . $start->toAtomString() . ' - ' . $end->toAtomString());
            $this->addDetail($start->format('U'), $end->format('U'));
        }

// If we don't have any recurrence, we are done
        if (empty($this->recurrenceType) || empty($this->recurrenceDetail))
            return;

// Detect invalid recurrences and quit early
        if (!$this->isCustomDayPart() && ($this->recurrenceType == 'Minute' || $this->recurrenceType == 'Hour'))
            return;

// Check the cache
        $item = $this->pool->getItem('schedule/' . $this->eventId . '/' . $generateFromDt->format('Y-m'));

if ($item->isHit()) {
            $this->scheduleEvents = $item->get();
            $this->getLog()->debug('Returning from cache! [eventId:' . $this->eventId . ']');
            return;
        }

$this->getLog()->debug('Cache miss! [eventId:' . $this->eventId . ']');

// vv anything below here means that the event window requested is not in the cache vv
        // WE ARE NOT IN THE CACHE
        // this means we need to always walk the tree from the last watermark
        // if the last watermark is after the from window, then we need to walk from the beginning

// Handle recurrence
        $originalStart = $start->copy();
        $lastWatermark = ($this->lastRecurrenceWatermark != 0) ?
            $this->getDate()->parse($this->lastRecurrenceWatermark, 'U')
            : $this->getDate()->parse(self::$DATE_MIN, 'U');

$this->getLog()->debug('Recurrence calculation required - last water mark is set to: ' . $lastWatermark->toRssString()
            . '. Event dates: ' . $start->toRssString() . ' - ' . $end->toRssString() . ' [eventId:' . $this->eventId . ']');

// Set the temp starts
        // the start date should be the latest of the event start date and the last recurrence date
        if ($lastWatermark > $start && $lastWatermark < $generateFromDt) {
            $this->getLog()->debug('The last watermark is later than the event start date and the generate from dt, using the watermark for forward population'
                . ' [eventId:' . $this->eventId . ']');

// Need to set the toDt based on the original event duration and the watermark start date
            $eventDuration = $start->diffInSeconds($end, true);

/** @var Date $start */
            $start = $lastWatermark->copy();
            $end = $start->copy()->addSeconds($eventDuration);

if ($start <= $generateToDt && $end >= $generateFromDt) {
                $this->addDetail($start->format('U'), $end->format('U'));
                $this->getLog()->debug('The event start/end is inside the month' );
            }
        }

// range should be the smallest of the recurrence range and the generate window todt
        // the start/end date should be the the first recurrence in the current window
        if ($this->recurrenceRange != 0) {
            $range = $this->getDate()->parse($this->recurrenceRange, 'U');

// Override the range to be within the period we are looking
            $range = ($range < $generateToDt) ? $range : $generateToDt->copy();
        } else {
            $range = $generateToDt->copy();
        }

$this->getLog()->debug('[' . $generateFromDt->toRssString() . ' - ' . $generateToDt->toRssString()
            . '] Looping from ' . $start->toRssString() . ' to ' . $range->toRssString() . ' [eventId:' . $this->eventId . ']');

// loop until we have added the recurring events for the schedule
        while ($start < $range)
        {
            $this->getLog()->debug('Loop: ' . $start->toRssString() . ' to ' . $range->toRssString() . ' [eventId:' . $this->eventId . ', end: ' . $end->toRssString() . ']');

// add the appropriate time to the start and end
            switch ($this->recurrenceType)
            {
                case 'Minute':
                    $start->minute($start->minute + $this->recurrenceDetail);
                    $end->minute($end->minute + $this->recurrenceDetail);
                    break;

case 'Hour':
                    $start->hour($start->hour + $this->recurrenceDetail);
                    $end->hour($end->hour + $this->recurrenceDetail);
                    break;

case 'Day':
                    $start->day($start->day + $this->recurrenceDetail);
                    $end->day($end->day + $this->recurrenceDetail);
                    break;

case 'Week':
                    // recurrenceRepeatsOn will contain an array we can use to determine which days it should repeat
                    // on. Roll forward 7 days, adding each day we hit
                    // if we go over the start of the week, then jump forward by the recurrence range
                    if (!empty($this->recurrenceRepeatsOn)) {
                        // Parse days selected and add the necessary events
                        $daysSelected = explode(',', $this->recurrenceRepeatsOn);

// Are we on the start day of this week already?
                        $onStartOfWeek = ($start->copy()->setTimeFromTimeString('00:00:00') == $start->copy()->startOfWeek()->setTimeFromTimeString('00:00:00'));

// What is the end of this week
                        $endOfWeek = $start->copy()->endOfWeek();

$this->getLog()->debug('Days selected: ' . $this->recurrenceRepeatsOn . '. End of week = ' . $endOfWeek . ' start date ' . $start . ' [eventId:' . $this->eventId . ']');

for ($i = 1; $i <= 7; $i++) {
                            // Add a day to the start dates
                            // after the first pass, we will already be on the first day of the week
                            if ($i > 1 || !$onStartOfWeek) {
                                $start->day($start->day + 1);
                                $end->day($end->day + 1);
                            }

$this->getLog()->debug('Assessing start date ' . $start->toAtomString()
                                . ', isoDayOfWeek is ' . $start->dayOfWeekIso . ' [eventId:' . $this->eventId . ']');

// If we go over the recurrence range, stop
                            // if we go over the start of the week, stop
                            if ($start > $range || $start > $endOfWeek) {
                                break;
                            }

// Is this day set?
                            if (!in_array($start->dayOfWeekIso, $daysSelected)) {
                                continue;
                            }

if ($start >= $generateFromDt) {
                                $this->getLog()->debug('Adding detail for ' . $start->toAtomString() . ' to ' . $end->toAtomString());

if ($this->eventTypeId == self::$COMMAND_EVENT) {
                                    $this->addDetail($start->format('U'), null);
                                }
                                else {
                                    // If we are a daypart event, look up the start/end times for the event
                                    $this->calculateDayPartTimes($start, $end);

$this->addDetail($start->format('U'), $end->format('U'));
                                }
                            } else {
                                $this->getLog()->debug('Event is outside range');
                            }
                        }

$this->getLog()->debug('Finished 7 day roll forward, start date is ' . $start . ' [eventId:' . $this->eventId . ']');

// If we haven't passed the end of the week, roll forward
                        if ($start < $endOfWeek) {
                            $start->day($start->day + 1);
                            $end->day($end->day + 1);
                        }

// Wind back a week and then add our recurrence detail
                        $start->day($start->day - 7);
                        $end->day($end->day - 7);

$this->getLog()->debug('Resetting start date to ' . $start . ' [eventId:' . $this->eventId . ']');
                    }

// Jump forward a week from the original start date (when we entered this loop)
                    $start->day($start->day + ($this->recurrenceDetail * 7));
                    $end->day($end->day + ($this->recurrenceDetail * 7));

break;

case 'Month':
                    // Are we repeating on the day of the month, or the day of the week
                    if ($this->recurrenceMonthlyRepeatsOn == 1) {
                        // Week day repeat
                        $difference = $end->diffInSeconds($start);

// Work out the position in the month of this day and the ordinal
                        $ordinals = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh'];
                        $ordinal = $ordinals[ceil($originalStart->day / 7) - 1];
                        $start->month($start->month + $this->recurrenceDetail)->modify($ordinal . ' ' . $originalStart->format('l') . ' of ' . $start->format('F Y'))->setTimeFrom($originalStart);

$this->getLog()->debug('Setting start to: ' . $ordinal . ' ' . $start->format('l') . ' of ' . $start->format('F Y'));

// Base the end on the start + difference
                        $end = $start->copy()->addSeconds($difference);
                    } else {
                        // Day repeat
                        $start->month($start->month + $this->recurrenceDetail);
                        $end->month($end->month + $this->recurrenceDetail);
                    }
                    break;

case 'Year':
                    $start->year($start->year + $this->recurrenceDetail);
                    $end->year($end->year + $this->recurrenceDetail);
                    break;

default:
                    throw new InvalidArgumentException('Invalid recurrence type', 'recurrenceType');
            }

// after we have added the appropriate amount, are we still valid
            if ($start > $range) {
                $this->getLog()->debug('Breaking mid loop because we\'ve exceeded the range. Start: ' . $start->toRssString() . ', range: ' . $range->toRssString() . ' [eventId:' . $this->eventId . ']');
                break;
            }

// Push the watermark
            $lastWatermark = $start->copy();

// Don't add if we are weekly recurrency (handles it's own adding)
            if ($this->recurrenceType == 'Week' && !empty($this->recurrenceRepeatsOn))
                continue;

if ($start <= $generateToDt && $end >= $generateFromDt) {
                if ($this->eventTypeId == self::$COMMAND_EVENT)
                    $this->addDetail($start->format('U'), null);
                else {
                    // If we are a daypart event, look up the start/end times for the event
                    $this->calculateDayPartTimes($start, $end);

$this->addDetail($start->format('U'), $end->format('U'));
                }
            }
        }

$this->getLog()->debug('Our last recurrence watermark is: ' . $lastWatermark->toRssString() . '[eventId:' . $this->eventId . ']');

// Update our schedule with the new last watermark
        $lastWatermarkTimeStamp = $lastWatermark->format('U');

if ($lastWatermarkTimeStamp != $this->lastRecurrenceWatermark) {
            $this->lastRecurrenceWatermark = $lastWatermarkTimeStamp;
            $this->getStore()->update('UPDATE `schedule` SET lastRecurrenceWatermark = :lastRecurrenceWatermark WHERE eventId = :eventId', [
                'eventId' => $this->eventId,
                'lastRecurrenceWatermark' => $this->lastRecurrenceWatermark
            ]);
        }

// Update the cache
        $item->set($this->scheduleEvents);
        $item->expiresAt(Date::now()->addMonths(2));

$this->pool->saveDeferred($item);

return;
    }

/**
     * Drop the event cache
     * @param $key
     */
    private function dropEventCache($key = null)
    {
        $compKey = 'schedule/' . $this->eventId;

if ($key !== null)
            $compKey .= '/' . $key;

$this->pool->deleteItem($compKey);
    }

/**
     * Calculate the DayPart times
     * @param Date $start
     * @param Date $end
     * @throws XiboException
     */
    private function calculateDayPartTimes($start, $end)
    {
        $dayOfWeekLookup = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];

if (!$this->isAlwaysDayPart() && !$this->isCustomDayPart()) {

// End is always based on Start
            $end->setTimestamp($start->format('U'));

$dayPart = $this->dayPartFactory->getById($this->dayPartId);

$this->getLog()->debug('Start and end time for dayPart is ' . $dayPart->startTime . ' - ' . $dayPart->endTime);

// What day of the week does this start date represent?
            // dayOfWeek is 0 for Sunday to 6 for Saturday
            $found = false;
            foreach ($dayPart->exceptions as $exception) {
                // Is there an exception for this day of the week?
                if ($exception['day'] == $dayOfWeekLookup[$start->dayOfWeek]) {
                    $start->setTimeFromTimeString($exception['start']);
                    $end->setTimeFromTimeString($exception['end']);

if ($start >= $end)
                        $end->addDay();

$this->getLog()->debug('Found exception Start and end time for dayPart exception is ' . $exception['start'] . ' - ' . $exception['end']);
                    $found = true;
                    break;
                }
            }

if (!$found) {
                // Set the time section of our dates based on the daypart date
                $start->setTimeFromTimeString($dayPart->startTime);
                $end->setTimeFromTimeString($dayPart->endTime);

if ($start >= $end) {
                    $this->getLog()->debug('Start is ahead of end - adding a day to the end date');
                    $end->addDay();
                }
            }
        }
    }

/**
     * Add Detail
     * @param int $fromDt
     * @param int $toDt
     */
    private function addDetail($fromDt, $toDt)
    {
        $this->scheduleEvents[] = new ScheduleEvent($fromDt, $toDt);
    }

/**
     * Manage the assignments
     * @param bool $notify should we notify or not?
     * @throws \Xibo\Exception\XiboException
     */
    private function manageAssignments($notify)
    {
        $this->linkDisplayGroups();
        $this->unlinkDisplayGroups();

$this->getLog()->debug('manageAssignments: Assessing whether we need to notify');
        $originalDisplayGroups = $this->getOriginalValue('displayGroups');

// Get the difference between the original display groups assigned and the new display groups assigned
        if ($notify && $originalDisplayGroups !== null && $this->inScheduleLookAhead()) {
            $diff = [];
            foreach ($originalDisplayGroups as $element) {
                /** @var \Xibo\Entity\DisplayGroup $element */
                $diff[$element->getId()] = $element;
            }

if (count($diff) > 0) {
                $this->getLog()->debug('manageAssignments: There are ' . count($diff) . ' existing DisplayGroups on this Event');
                $ids = array_map(function ($element) {
                    return $element->getId();
                }, $this->displayGroups);

$except = array_diff(array_keys($diff), $ids);

if (count($except) > 0) {
                    foreach ($except as $item) {
                        $this->getLog()->debug('manageAssignments: calling notify on displayGroupId ' . $diff[$item]->getId());
                        $this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByDisplayGroupId($diff[$item]->getId());
                    }
                } else {
                    $this->getLog()->debug('manageAssignments: No need to notify');
                }
            } else {
                $this->getLog()->debug('manageAssignments: No change to DisplayGroup assignments');
            }
        } else {
            $this->getLog()->debug('manageAssignments: Not in look-ahead');
        }
    }

/**
     * Link Layout
     */
    private function linkDisplayGroups()
    {
        // TODO: Make this more efficient by storing the prepared SQL statement
        $sql = 'INSERT INTO `lkscheduledisplaygroup` (eventId, displayGroupId) VALUES (:eventId, :displayGroupId) ON DUPLICATE KEY UPDATE displayGroupId = displayGroupId';

$i = 0;
        foreach ($this->displayGroups as $displayGroup) {
            $i++;

$this->getStore()->insert($sql, array(
                'eventId' => $this->eventId,
                'displayGroupId' => $displayGroup->displayGroupId
            ));
        }
    }

/**
     * Unlink Layout
     */
    private function unlinkDisplayGroups()
    {
        // Unlink any layouts that are NOT in the collection
        $params = ['eventId' => $this->eventId];

$sql = 'DELETE FROM `lkscheduledisplaygroup` WHERE eventId = :eventId AND displayGroupId NOT IN (0';

$i = 0;
        foreach ($this->displayGroups as $displayGroup) {
            $i++;
            $sql .= ',:displayGroupId' . $i;
            $params['displayGroupId' . $i] = $displayGroup->displayGroupId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Is this event an always daypart event
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function isAlwaysDayPart()
    {
        $dayPart = $this->dayPartFactory->getById($this->dayPartId);

return $dayPart->isAlways === 1;
    }

/**
     * Is this event a custom daypart event
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function isCustomDayPart()
    {
        $dayPart = $this->dayPartFactory->getById($this->dayPartId);

return $dayPart->isCustom === 1;
    }

/**
     * Get next reminder date
     * @param Date $now
     * @param ScheduleReminder $reminder
     * @param int $remindSeconds
     * @return int|null
     * @throws NotFoundException
     * @throws XiboException
     */
    public function getNextReminderDate($now, $reminder, $remindSeconds) {

// Determine toDt so that we don't getEvents which never ends
        // adding the recurrencedetail at the end (minute/hour/week) to make sure we get at least 2 next events
        $toDt = $now->copy();

// For a future event we need to forward now to event fromDt
        $fromDt = $this->getDate()->parse($this->fromDt, 'U');
        if ( $fromDt > $toDt ) {
            $toDt = $fromDt;
        }

switch ($this->recurrenceType)
        {

case 'Minute':
                $toDt->minute(($toDt->minute + $this->recurrenceDetail) + $this->recurrenceDetail);
                break;

case 'Hour':
                $toDt->hour(($toDt->hour + $this->recurrenceDetail) + $this->recurrenceDetail);
                break;

case 'Day':
                $toDt->day(($toDt->day + $this->recurrenceDetail) + $this->recurrenceDetail);
                break;

case 'Week':
                $toDt->day(($toDt->day + $this->recurrenceDetail * 7 ) + $this->recurrenceDetail);
                break;

case 'Month':
                $toDt->month(($toDt->month + $this->recurrenceDetail ) + $this->recurrenceDetail);
                break;

case 'Year':
                $toDt->year(($toDt->year + $this->recurrenceDetail ) + $this->recurrenceDetail);
                break;

default:
                throw new InvalidArgumentException('Invalid recurrence type', 'recurrenceType');
        }

// toDt is set so that we get two next events from now
        $scheduleEvents = $this->getEvents($now, $toDt);

foreach($scheduleEvents as $event) {
            if ($reminder->option == ScheduleReminder::$OPTION_BEFORE_START) {
                $reminderDt = $event->fromDt - $remindSeconds;
                if ($reminderDt >= $now->format('U')) {
                    return $reminderDt;
                }
            } elseif ($reminder->option == ScheduleReminder::$OPTION_AFTER_START) {
                $reminderDt = $event->fromDt + $remindSeconds;
                if ($reminderDt >= $now->format('U')) {
                    return $reminderDt;
                }
            } elseif ($reminder->option == ScheduleReminder::$OPTION_BEFORE_END) {
                $reminderDt = $event->toDt - $remindSeconds;
                if ($reminderDt >= $now->format('U')) {
                    return $reminderDt;
                }
            } elseif ($reminder->option == ScheduleReminder::$OPTION_AFTER_END) {
                $reminderDt = $event->toDt + $remindSeconds;
                if ($reminderDt >= $now->format('U')) {
                    return $reminderDt;
                }
            }
        }

// No next event exist
        throw new NotFoundException('reminderDt not found as next event does not exist');
    }

/**
     * Get event title
     * @return string
     * @throws XiboException
     */
    public function getEventTitle() {

// Setting for whether we show Layouts with out permissions
        $showLayoutName = ($this->config->getSetting('SCHEDULE_SHOW_LAYOUT_NAME') == 1);

// Load the display groups
        $this->load();

$displayGroupList = '';

if (count($this->displayGroups) >= 0) {
            $array = array_map(function ($object) {
                return $object->displayGroup;
            }, $this->displayGroups);
            $displayGroupList = implode(', ', $array);
        }

$user = $this->userFactory->getById($this->userId);

// Event Title
        if ($this->campaignId == 0) {
            // Command
            $title = __('%s scheduled on %s', $this->command, $displayGroupList);
        } else {
            // Should we show the Layout name, or not (depending on permission)
            // Make sure we only run the below code if we have to, its quite expensive
            if (!$showLayoutName && !$user->isSuperAdmin()) {
                // Campaign
                $campaign = $this->campaignFactory->getById($this->campaignId);

if (!$user->checkViewable($campaign))
                    $this->campaign = __('Private Item');
            }
            $title = __('%s scheduled on %s', $this->campaign, $displayGroupList);
        }

return $title;
    }
}PK�������qY���xU	��U	����RegionOption.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (RegionOptions.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class RegionOption
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class RegionOption implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The regionId that this Option applies to")
     * @var int
     */
    public $regionId;

/**
     * @SWG\Property(description="The option name")
     * @var string
     */
    public $option;

/**
     * @SWG\Property(description="The option value")
     * @var string
     */
    public $value;

/**
     * Clone
     */
    public function __clone()
    {
        $this->regionId = null;
    }

public function save()
    {
        $sql = 'INSERT INTO `regionoption` (`regionId`, `option`, `value`) VALUES (:regionId, :option, :value) ON DUPLICATE KEY UPDATE `value` = :value2';
        $this->getStore()->insert($sql, array(
            'regionId' => $this->regionId,
            'option' => $this->option,
            'value' => $this->value,
            'value2' => $this->value,
        ));
    }

public function delete()
    {
        $sql = 'DELETE FROM `regionoption` WHERE `regionId` = :regionId AND `option` = :option';
        $this->getStore()->update($sql, array('regionId' => $this->regionId, 'option' => $this->option));
    }
}PK�������qY��y�L��L����PlayerVersion.phpnu��[�����������<?php
/**
* Copyright (C) 2018 Xibo Signage Ltd
*
* Xibo - Digital Signage - http://www.xibo.org.uk
*
* This file is part of Xibo.
*
* Xibo is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* Xibo is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
*/
namespace Xibo\Entity;

use Xibo\Exception\XiboException;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\PlayerVersionFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
* Class PlayerVersion
* @package Xibo\Entity
*
* @SWG\Definition()
*/
class PlayerVersion implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="Version ID")
     * @var int
     */
    public $versionId;

/**
     * @SWG\Property(description="Player type")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="Version number")
     * @var string
     */
    public $version;

/**
     * @SWG\Property(description="Code number")
     * @var int
     */
    public $code;

/**
     * @SWG\Property(description="A comma separated list of groups/users with permissions to this Media")
     * @var string
     */
    public $groupsWithPermissions;

/**
     * @SWG\Property(description="The Media ID")
     * @var int
     */
    public $mediaId;

/**
     * @SWG\Property(description="Player version to show")
     * @var string
     */
    public $playerShowVersion;

/**
     * @SWG\Property(description="Original name of the uploaded installer file")
     * @var string
     */
    public $originalFileName;

/**
     * @SWG\Property(description="Stored As")
     * @var string
     */
    public $storedAs;

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var PlayerVersionFactory
     */
    private $playerVersionFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param MediaFactory $mediaFactory
     * @param PlayerVersionFactory $playerVersionFactory
     */
    public function __construct($store, $log, $config, $mediaFactory, $playerVersionFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->config = $config;
        $this->mediaFactory = $mediaFactory;
        $this->playerVersionFactory = $playerVersionFactory;
    }

/**
     * Add
     */
    private function add()
    {
        $this->versionId = $this->getStore()->insert('
            INSERT INTO `player_software` (`player_type`, `player_version`, `player_code`, `mediaId`, `playerShowVersion`)
              VALUES (:type, :version, :code, :mediaId, :playerShowVersion)
        ', [
            'type' => $this->type,
            'version' => $this->version,
            'code' => $this->code,
            'mediaId' => $this->mediaId,
            'playerShowVersion' => $this->playerShowVersion
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $sql = '
          UPDATE `player_software`
            SET `player_version` = :version,
                `player_code` = :code,
                `playerShowVersion` = :playerShowVersion
           WHERE versionId = :versionId
        ';

$params = [
            'version' => $this->version,
            'code' => $this->code,
            'playerShowVersion' => $this->playerShowVersion,
            'versionId' => $this->versionId
        ];

$this->getStore()->update($sql, $params);
    }

/**
     * Delete
     * @throws XiboException
     */
    public function delete()
    {
        $this->load();

$this->getStore()->update('DELETE FROM `player_software` WHERE `versionId` = :versionId', [
            'versionId' => $this->versionId
        ]);
    }

/**
     * Load
     */
    public function load()
    {
        if ($this->loaded || $this->versionId == null)
            return;

$this->loaded = true;
    }

/**
     * Save this media
     * @param array $options
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true
        ], $options);

if ($this->versionId == null || $this->versionId == 0)
            $this->add();
        else
            $this->edit();
    }
}PK�������qY|kPh��������DataSetColumnType.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (DataSetColumnType.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DataSetColumnType
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DataSetColumnType implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID for this DataSetColumnType")
     * @var int
     */
    public $dataSetColumnTypeId;

/**
     * @SWG\Property(description="The name for this DataSetColumnType")
     * @var string
     */
    public $dataSetColumnType;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     */
    public function __construct($store, $log)
    {
        $this->setCommonDependencies($store, $log);
    }
}PK�������qY���Ag��g����ScheduleEvent.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (ScheduleEvent.php)
 */

namespace Xibo\Entity;

/**
 * Class ScheduleEvent
 * @package Xibo\Entity
 */
class ScheduleEvent
{
    public $fromDt;
    public $toDt;

/**
     * ScheduleEvent constructor.
     * @param $fromDt
     * @param $toDt
     */
    public function __construct($fromDt, $toDt)
    {
        $this->fromDt = $fromDt;
        $this->toDt = $toDt;
    }

/**
     * @return string
     */
    public function __toString()
    {
        return $this->fromDt . $this->toDt;
    }
}PK�������qY��&�z2��z2����Notification.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (Notification.php)
 */

namespace Xibo\Entity;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\UserGroupFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Notification
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Notification implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="The Notifcation ID"
     * )
     * @var int
     */
    public $notificationId;

/**
     * @SWG\Property(
     *  description="Create Date as Unix Timestamp"
     * )
     * @var int
     */
    public $createdDt;

/**
     * @SWG\Property(
     *  description="Release Date as Unix Timestamp"
     * )
     * @var int
     */
    public $releaseDt;

/**
     * @SWG\Property(
     *  description="The subject line"
     * )
     * @var string
     */
    public $subject;

/**
     * @SWG\Property(
     *  description="The HTML body of the notification"
     * )
     * @var string
     */
    public $body;

/**
     * @SWG\Property(
     *  description="Should the notification be emailed"
     * )
     * @var int
     */
    public $isEmail = 0;

/**
     * @SWG\Property(
     *  description="Should the notification interrupt the CMS UI on navigate/login"
     * )
     * @var int
     */
    public $isInterrupt = 0;

/**
     * @SWG\Property(
     *  description="Flag for system notification"
     * )
     * @var int
     */
    public $isSystem = 0;

/**
     * @SWG\Property(
     *  description="The Owner User Id"
     * )
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(
     *  description="Attachment filename"
     * )
     * @var string
     */
    public $filename;

/**
     * @SWG\Property(
     *  description="Attachment originalFileName"
     * )
     * @var string
     */
    public $originalFileName;

/**
     * @SWG\Property(
     *  description="Additional email addresses to which a saved report will be sent"
     * )
     * @var string
     */
    public $nonusers;

/**
     * @SWG\Property(
     *  description="User Group Notifications associated with this notification"
     * )
     * @var UserGroup[]
     */
    public $userGroups = [];

/**
     * @SWG\Property(
     *  description="Display Groups associated with this notification"
     * )
     * @var DisplayGroup[]
     */
    public $displayGroups = [];

/** @var  UserGroupFactory */
    private $userGroupFactory;

/** @var  DisplayGroupFactory */
    private $displayGroupFactory;

/**
     * Command constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param UserGroupFactory $userGroupFactory
     * @param DisplayGroupFactory $displayGroupFactory
     */
    public function __construct($store, $log, $userGroupFactory, $displayGroupFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->userGroupFactory = $userGroupFactory;
        $this->displayGroupFactory = $displayGroupFactory;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->notificationId;
    }

/**
     * Get Owner
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Add User Group Notification
     * @param UserGroup $userGroup
     */
    public function assignUserGroup($userGroup)
    {
        $this->load();

if (!in_array($userGroup, $this->userGroups))
            $this->userGroups[] = $userGroup;
    }

/**
     * Add Display Group
     * @param DisplayGroup $displayGroup
     */
    public function assignDisplayGroup($displayGroup)
    {
        $this->load();

if (!in_array($displayGroup, $this->displayGroups))
            $this->displayGroups[] = $displayGroup;
    }

/**
     * Validate
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if (empty($this->subject))
            throw new InvalidArgumentException(__('Please provide a subject'), 'subject');

if (empty($this->body))
            throw new InvalidArgumentException(__('Please provide a body'), 'body');
    }

/**
     * Load
     * @param array $options
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadUserGroups' => true,
            'loadDisplayGroups' => true,
        ], $options);

if ($this->loaded || $this->notificationId == null)
            return;

// Load the Display Groups and User Group Notifications
        if ($options['loadUserGroups'])
            $this->userGroups = $this->userGroupFactory->getByNotificationId($this->notificationId);

if ($options['loadDisplayGroups'])
            $this->displayGroups = $this->displayGroupFactory->getByNotificationId($this->notificationId);

$this->loaded = true;
    }

/**
     * Save Notification
     */
    public function save()
    {
        $this->validate();

if ($this->notificationId == null)
            $this->add();
        else
            $this->edit();

$this->manageAssignments();
    }

/**
     * Delete Notification
     */
    public function delete()
    {
        // Remove all links
        $this->getStore()->update('DELETE FROM `lknotificationuser` WHERE `notificationId` = :notificationId', ['notificationId' => $this->notificationId]);

$this->getStore()->update('DELETE FROM `lknotificationgroup` WHERE `notificationId` = :notificationId', ['notificationId' => $this->notificationId]);

$this->getStore()->update('DELETE FROM `lknotificationdg` WHERE `notificationId` = :notificationId', ['notificationId' => $this->notificationId]);

// Remove the notification
        $this->getStore()->update('DELETE FROM `notification` WHERE `notificationId` = :notificationId', ['notificationId' => $this->notificationId]);
    }

/**
     * Add to DB
     */
    private function add()
    {
        $this->notificationId = $this->getStore()->insert('
            INSERT INTO `notification`
              (`subject`, `body`, `createDt`, `releaseDt`, `isEmail`, `isInterrupt`, `isSystem`, `userId`, `filename`, `originalFileName`, `nonusers`)
              VALUES (:subject, :body, :createDt, :releaseDt, :isEmail, :isInterrupt, :isSystem, :userId, :filename, :originalFileName, :nonusers)
        ', [
            'subject' => $this->subject,
            'body' => $this->body,
            'createDt' => $this->createdDt,
            'releaseDt' => $this->releaseDt,
            'isEmail' => $this->isEmail,
            'isInterrupt' => $this->isInterrupt,
            'isSystem' => $this->isSystem,
            'userId' => $this->userId,
            'filename' => $this->filename,
            'originalFileName' => $this->originalFileName,
            'nonusers' => $this->nonusers
        ]);
    }

/**
     * Update in DB
     */
    private function edit()
    {
        $this->getStore()->update('
            UPDATE `notification` SET `subject` = :subject,
                `body` = :body,
                `createDt` = :createDt,
                `releaseDt` = :releaseDt,
                `isEmail` = :isEmail,
                `isInterrupt` = :isInterrupt,
                `isSystem` = :isSystem,
                `userId` = :userId,
                `filename` = :filename,
                `originalFileName` = :originalFileName,
                `nonusers` = :nonusers
              WHERE `notificationId` = :notificationId
        ', [
            'subject' => $this->subject,
            'body' => $this->body,
            'createDt' => $this->createdDt,
            'releaseDt' => $this->releaseDt,
            'isEmail' => $this->isEmail,
            'isInterrupt' => $this->isInterrupt,
            'isSystem' => $this->isSystem,
            'userId' => $this->userId,
            'filename' => $this->filename,
            'originalFileName' => $this->originalFileName,
            'nonusers' => $this->nonusers,
            'notificationId' => $this->notificationId
        ]);
    }

/**
     * Manage assignements in DB
     */
    private function manageAssignments()
    {
        $this->linkUserGroups();
        $this->unlinkUserGroups();

$this->linkDisplayGroups();
        $this->unlinkDisplayGroups();

$this->manageRealisedUserLinks();
    }

/**
     * Manage the links in the User notification table
     */
    private function manageRealisedUserLinks()
    {
        // Delete links that no longer exist
        $this->getStore()->update('
            DELETE FROM `lknotificationuser`
             WHERE `notificationId` = :notificationId AND `userId` NOT IN (
                SELECT `userId`
                  FROM `lkusergroup`
                    INNER JOIN `lknotificationgroup`
                    ON `lknotificationgroup`.groupId = `lkusergroup`.groupId
                 WHERE `lknotificationgroup`.notificationId = :notificationId2
              ) AND userId <> 0
        ', [
            'notificationId' => $this->notificationId,
            'notificationId2' => $this->notificationId
        ]);

// Pop in new links following from this adjustment
        $this->getStore()->update('
            INSERT INTO `lknotificationuser` (`notificationId`, `userId`, `read`, `readDt`, `emailDt`)
            SELECT DISTINCT :notificationId, `userId`, 0, 0, 0
              FROM `lkusergroup`
                INNER JOIN `lknotificationgroup`
                ON `lknotificationgroup`.groupId = `lkusergroup`.groupId
             WHERE `lknotificationgroup`.notificationId = :notificationId2
            ON DUPLICATE KEY UPDATE userId = `lknotificationuser`.userId
        ', [
            'notificationId' => $this->notificationId,
            'notificationId2' => $this->notificationId
        ]);

if ($this->isSystem) {
            $this->getStore()->insert('
            INSERT INTO `lknotificationuser` (`notificationId`, `userId`, `read`, `readDt`, `emailDt`)
              VALUES (:notificationId, :userId, 0, 0, 0)
              ON DUPLICATE KEY UPDATE userId = `lknotificationuser`.userId
            ', [
                'notificationId' => $this->notificationId,
                'userId' => $this->userId
            ]);
        }
    }

/**
     * Link User Groups
     */
    private function linkUserGroups()
    {
        foreach ($this->userGroups as $userGroup) {
            /* @var UserGroup $userGroup */
            $this->getStore()->update('INSERT INTO `lknotificationgroup` (notificationId, groupId) VALUES (:notificationId, :userGroupId) ON DUPLICATE KEY UPDATE groupId = groupId', [
                'notificationId' => $this->notificationId,
                'userGroupId' => $userGroup->groupId
            ]);
        }
    }

/**
     * Unlink User Groups
     */
    private function unlinkUserGroups()
    {
        // Unlink any userGroup that is NOT in the collection
        $params = ['notificationId' => $this->notificationId];

$sql = 'DELETE FROM `lknotificationgroup` WHERE notificationId = :notificationId AND groupId NOT IN (0';

$i = 0;
        foreach ($this->userGroups as $userGroup) {
            /* @var UserGroup $userGroup */
            $i++;
            $sql .= ',:userGroupId' . $i;
            $params['userGroupId' . $i] = $userGroup->groupId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Link Display Groups
     */
    private function linkDisplayGroups()
    {
        foreach ($this->displayGroups as $displayGroup) {
            /* @var DisplayGroup $displayGroup */
            $this->getStore()->update('INSERT INTO `lknotificationdg` (notificationId, displayGroupId) VALUES (:notificationId, :displayGroupId) ON DUPLICATE KEY UPDATE displayGroupId = displayGroupId', [
                'notificationId' => $this->notificationId,
                'displayGroupId' => $displayGroup->displayGroupId
            ]);
        }
    }

/**
     * Unlink Display Groups
     */
    private function unlinkDisplayGroups()
    {
        // Unlink any displayGroup that is NOT in the collection
        $params = ['notificationId' => $this->notificationId];

$sql = 'DELETE FROM `lknotificationdg` WHERE notificationId = :notificationId AND displayGroupId NOT IN (0';

$i = 0;
        foreach ($this->displayGroups as $displayGroup) {
            /* @var DisplayGroup $displayGroup */
            $i++;
            $sql .= ',:displayGroupId' . $i;
            $params['displayGroupId' . $i] = $displayGroup->displayGroupId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }
}PK�������qY�_��������DataSetRss.phpnu��[�����������<?php
/**
 * Copyright (C) 2018 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;

use Xibo\Helper\Random;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DataSetRss
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DataSetRss implements \JsonSerializable
{
    use EntityTrait;

public $id;
    public $dataSetId;
    public $titleColumnId;
    public $summaryColumnId;
    public $contentColumnId;
    public $publishedDateColumnId;

public $psk;
    public $title;
    public $author;

public $sort;
    public $filter;

/**
     * @return array|mixed
     */
    public function getFilter()
    {
        return ($this->filter == '') ? ['filter' => '', 'useFilteringClause' => 0, 'filterClauses' => []] : json_decode($this->filter, true);
    }

/**
     * @return array|mixed
     */
    public function getSort()
    {
        return ($this->sort == '') ? ['sort' => '', 'useOrderingClause' => 0, 'orderClauses' => []] : json_decode($this->sort, true);
    }

/**
     * Save
     */
    public function save()
    {
        if ($this->id == null) {
            $this->add();

$this->audit($this->id, 'Added', []);
        } else {
            $this->edit();

$this->audit($this->id, 'Saved');
        }
    }

/**
     * @return $this
     * @throws \Exception
     */
    public function setNewPsk()
    {
        $this->psk = Random::generateString(12);
        return $this;
    }

/**
     * Delete
     */
    public function delete()
    {
        $this->getStore()->update('DELETE FROM `datasetrss` WHERE id = :id', ['id' => $this->id]);

$this->audit($this->id, 'Deleted');
    }

private function add()
    {
        $this->id = $this->getStore()->insert('
            INSERT INTO datasetrss (dataSetId, psk, title, author, titleColumnId, summaryColumnId, contentColumnId, publishedDateColumnId, sort, filter) VALUES 
             (:dataSetId, :psk, :title, :author, :titleColumnId, :summaryColumnId, :contentColumnId, :publishedDateColumnId, :sort, :filter)
        ', [
            'dataSetId' => $this->dataSetId,
            'psk' => $this->psk,
            'title' => $this->title,
            'author' => $this->author,
            'titleColumnId' => $this->titleColumnId,
            'summaryColumnId' => $this->summaryColumnId,
            'contentColumnId' => $this->contentColumnId,
            'publishedDateColumnId' => $this->publishedDateColumnId,
            'sort' => $this->sort,
            'filter' => $this->filter
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
            UPDATE `datasetrss` SET
                psk = :psk,
                title = :title,
                author = :author,
                titleColumnId = :titleColumnId,
                summaryColumnId = :summaryColumnId,
                contentColumnId = :contentColumnId,
                publishedDateColumnId = :publishedDateColumnId,
                sort = :sort,
                filter = :filter
             WHERE id = :id
        ', [
            'id' => $this->id,
            'psk' => $this->psk,
            'title' => $this->title,
            'author' => $this->author,
            'titleColumnId' => $this->titleColumnId,
            'summaryColumnId' => $this->summaryColumnId,
            'contentColumnId' => $this->contentColumnId,
            'publishedDateColumnId' => $this->publishedDateColumnId,
            'sort' => $this->sort,
            'filter' => $this->filter
        ]);
    }
}PK�������qY������������Transition.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Transition.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Transition
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Transition
{
    use EntityTrait;

/**
     * @SWG\Property(description="The transition ID")
     * @var int
     */
    public $transitionId;

/**
     * @SWG\Property(description="The transition name")
     * @var string
     */
    public $transition;

/**
     * @SWG\Property(description="Code for transition")
     * @var string
     */
    public $code;

/**
     * @SWG\Property(description="Flag indicating whether this is a directional transition")
     * @var int
     */
    public $hasDirection;

/**
     * @SWG\Property(description="Flag indicating whether this transition has a duration option")
     * @var int
     */
    public $hasDuration;

/**
     * @SWG\Property(description="Flag indicating whether this transition should be available for IN assignments")
     * @var int
     */
    public $availableAsIn;

/**
     * @SWG\Property(description="Flag indicating whether this transition should be available for OUT assignments")
     * @var int
     */
    public $availableAsOut;

public function getId()
    {
        return $this->transitionId;
    }

public function getOwnerId()
    {
        return 1;
    }

public function save()
    {
        if ($this->transitionId == null || $this->transitionId == 0)
            throw new \InvalidArgumentException();

$this->getStore()->update('
            UPDATE `transition` SET AvailableAsIn = :availableAsIn, AvailableAsOut = :availableAsOut WHERE transitionID = :transitionId
        ', [
            'availableAsIn' => $this->availableAsIn,
            'availableAsOut' => $this->availableAsOut,
            'transitionId' => $this->transitionId
        ]);
    }
}PK�������qY��ۋ����������Display.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Stash\Interfaces\PoolInterface;
use Xibo\Exception\DeadlockException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\DisplayProfileFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Display
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Display implements \JsonSerializable
{
    public static $STATUS_DONE = 1;
    public static $STATUS_DOWNLOADING = 2;
    public static $STATUS_PENDING = 3;

use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Display")
     * @var int
     */
    public $displayId;

/**
     * @SWG\Property(description="Flag indicating whether this Display is recording Auditing Information from XMDS")
     * @var int
     */
    public $auditingUntil;

/**
     * @SWG\Property(description="The Name of this Display")
     * @var string
     */
    public $display;

/**
     * @SWG\Property(description="The Description of this Display")
     * @var string
     */
    public $description;

/**
     * @SWG\Property(description="The ID of the Default Layout")
     * @var int
     */
    public $defaultLayoutId = 4;

/**
     * @SWG\Property(description="The Display Unique Identifier also called hardware key")
     * @var string
     */
    public $license;

/**
     * @SWG\Property(description="A flag indicating whether this Display is licensed or not")
     * @var int
     */
    public $licensed;
    private $currentlyLicensed;

/**
     * @SWG\Property(description="A flag indicating whether this Display is currently logged in")
     * @var int
     */
    public $loggedIn;

/**
     * @SWG\Property(description="A timestamp in CMS time for the last time the Display accessed XMDS")
     * @var int
     */
    public $lastAccessed;

/**
     * @SWG\Property(description="A flag indicating whether the default layout is interleaved with the Schedule")
     * @var int
     */
    public $incSchedule;

/**
     * @SWG\Property(description="A flag indicating whether the Display will send email alerts.")
     * @var int
     */
    public $emailAlert;

/**
     * @SWG\Property(description="A timeout in seconds for the Display to send email alerts.")
     * @var int
     */
    public $alertTimeout;

/**
     * @SWG\Property(description="The MAC Address of the Display")
     * @var string
     */
    public $clientAddress;

/**
     * @SWG\Property(description="The media inventory status of the Display")
     * @var int
     */
    public $mediaInventoryStatus;

/**
     * @SWG\Property(description="The current Mac Address of the Player")
     * @var string
     */
    public $macAddress;

/**
     * @SWG\Property(description="A timestamp indicating the last time the Mac Address changed")
     * @var int
     */
    public $lastChanged;

/**
     * @SWG\Property(description="A count of Mac Address changes")
     * @var int
     */
    public $numberOfMacAddressChanges;

/**
     * @SWG\Property(description="A timestamp indicating the last time a WOL command was sent")
     * @var int
     */
    public $lastWakeOnLanCommandSent;

/**
     * @SWG\Property(description="A flag indicating whether Wake On Lan is enabled")
     * @var int
     */
    public $wakeOnLanEnabled;

/**
     * @SWG\Property(description="A h:i string indicating the time to send a WOL command")
     * @var string
     */
    public $wakeOnLanTime;

/**
     * @SWG\Property(description="The broad cast address for this Display")
     * @var string
     */
    public $broadCastAddress;

/**
     * @SWG\Property(description="The secureOn WOL settings for this display.")
     * @var string
     */
    public $secureOn;

/**
     * @SWG\Property(description="The CIDR WOL settings for this display")
     * @var string
     */
    public $cidr;

/**
     * @SWG\Property(description="The display Latitude")
     * @var double
     */
    public $latitude;

/**
     * @SWG\Property(description="The display longitude")
     * @var double
     */
    public $longitude;

/**
     * @SWG\Property(description="A string representing the player type")
     * @var string
     */
    public $clientType;

/**
     * @SWG\Property(description="A string representing the player version")
     * @var string
     */
    public $clientVersion;

/**
     * @SWG\Property(description="A number representing the Player version code")
     * @var int
     */
    public $clientCode;

/**
     * @SWG\Property(description="The display settings profile ID for this Display")
     * @var int
     */
    public $displayProfileId;

/**
     * @SWG\Property(description="The current layout ID reported via XMDS")
     * @var int
     */
    public $currentLayoutId;

/**
     * @SWG\Property(description="A flag indicating that a screen shot should be taken by the Player")
     * @var int
     */
    public $screenShotRequested;

/**
     * @SWG\Property(description="The number of bytes of storage available on the device.")
     * @var int
     */
    public $storageAvailableSpace;

/**
     * @SWG\Property(description="The number of bytes of storage in total on the device")
     * @var int
     */
    public $storageTotalSpace;

/**
     * @SWG\Property(description="The ID of the Display Group for this Device")
     * @var int
     */
    public $displayGroupId;

/**
     * @SWG\Property(description="The current layout")
     * @var string
     */
    public $currentLayout;

/**
     * @SWG\Property(description="The default layout")
     * @var string
     */
    public $defaultLayout;

/**
     * @SWG\Property(description="The Display Groups this Display belongs to")
     * @var DisplayGroup[]
     */
    public $displayGroups = [];

/**
     * @SWG\Property(description="The Player Subscription Channel")
     * @var string
     */
    public $xmrChannel;

/**
     * @SWG\Property(description="The Player Public Key")
     * @var string
     */
    public $xmrPubKey;

/**
     * @SWG\Property(description="The last command success, 0 = failure, 1 = success, 2 = unknown")
     * @var int
     */
    public $lastCommandSuccess = 0;

/**
     * @SWG\Property(description="The Device Name for the device hardware associated with this Display")
     * @var string
     */
    public $deviceName;

/**
     * @SWG\Property(description="The Display Timezone, or empty to use the CMS timezone")
     * @var string
     */
    public $timeZone;

/**
     * @SWG\Property(description="Tags associated with this Display")
     * @var Tag[]
     */
    public $tags;
    public $tagValues;

/**
     * @SWG\Property(description="The configuration options that will overwrite Display Profile Config")
     * @var string|array
     */
    public $overrideConfig = [];

/**
     * @SWG\Property(description="The display bandwidth limit")
     * @var int
     */
    public $bandwidthLimit;

/**
     * @SWG\Property(description="The new CMS Address")
     * @var string
     */
    public $newCmsAddress;

/**
     * @SWG\Property(description="The new CMS Key")
     * @var string
     */
    public $newCmsKey;

/**
     * @SWG\Property(description="The orientation of the Display, either landscape or portrait")
     * @var string
     */
    public $orientation;

/**
     * @SWG\Property(description="The resolution of the Display expressed as a string in the format WxH")
     * @var string
     */
    public $resolution;

/**
     * @SWG\Property(description="Status of the commercial licence for this Display. 0 - Not licensed, 1 - licensed, 2 - trial licence, 3 - not applicable")
     * @var int
     */
    public $commercialLicence;

/** @var array The configuration from the Display Profile  */
    private $profileConfig;

/** @var array Combined config */
    private $combinedConfig;

/** @var \Xibo\Entity\DisplayProfile the resolved DisplayProfile for this Display */
    private $_displayProfile;

/**
     * Commands
     * @var array[Command]
     */
    private $commands = null;

public static $saveOptionsMinimum = ['validate' => false, 'audit' => false];

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var DisplayGroupFactory
     */
    private $displayGroupFactory;

/**
     * @var DisplayProfileFactory
     */
    private $displayProfileFactory;

/**
     * @var DisplayFactory
     */
    private $displayFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var ScheduleFactory
     */
    private $scheduleFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param DisplayGroupFactory $displayGroupFactory
     * @param DisplayProfileFactory $displayProfileFactory
     * @param DisplayFactory $displayFactory
     */
    public function __construct($store, $log, $config, $displayGroupFactory, $displayProfileFactory, $displayFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->excludeProperty('mediaInventoryXml');
        $this->setPermissionsClass('Xibo\Entity\DisplayGroup');
        $this->setCanChangeOwner(false);

$this->config = $config;
        $this->displayGroupFactory = $displayGroupFactory;
        $this->displayProfileFactory = $displayProfileFactory;
        $this->displayFactory = $displayFactory;

// Initialise extra validation rules
        v::with('Xibo\\Validation\\Rules\\');
    }

/**
     * Set child object dependencies
     * @param LayoutFactory $layoutFactory
     * @param MediaFactory $mediaFactory
     * @param ScheduleFactory $scheduleFactory
     * @return $this
     */
    public function setChildObjectDependencies($layoutFactory, $mediaFactory, $scheduleFactory)
    {
        $this->layoutFactory = $layoutFactory;
        $this->mediaFactory = $mediaFactory;
        $this->scheduleFactory = $scheduleFactory;
        return $this;
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->displayGroupId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        // No owner
        return 0;
    }

/**
     * Get the cache key
     * @return string
     */
    public static function getCachePrefix()
    {
        return 'display/';
    }

/**
     * Get the cache key
     * @return string
     */
    public function getCacheKey()
    {
        return self::getCachePrefix() . $this->displayId;
    }

/**
     * @return \Xibo\Entity\DisplayProfile
     */
    public function getDisplayProfile()
    {
        if ($this->_displayProfile === null) {

try {
                if ($this->displayProfileId == 0) {
                    // Load the default profile
                    $displayProfile = $this->displayProfileFactory->getDefaultByType($this->clientType);
                } else {
                    // Load the specified profile
                    $displayProfile = $this->displayProfileFactory->getById($this->displayProfileId);
                }
            } catch (NotFoundException $e) {
                $this->getLog()->error('Cannot get display profile');
                $this->getLog()->debug($e->getTraceAsString());

$displayProfile = $this->displayProfileFactory->getUnknownProfile($this->clientType);
            }

// Set our display profile
            $this->_displayProfile = $displayProfile;

}

return $this->_displayProfile;
    }

/**
     * Is this display auditing?
     * return bool
     */
    public function isAuditing()
    {
        $this->getLog()->debug('Testing whether this display is auditing. %d vs %d.', $this->auditingUntil, time());
        // Test $this->auditingUntil against the current date.
        return ($this->auditingUntil >= time());
    }

/**
     * Set the Media Status to Incomplete
     */
    public function notify()
    {
        $this->getLog()->debug($this->display . ' requests notify');

$this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByDisplayId($this->displayId);
    }

/**
     * Validate the Object as it stands
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->display))
            throw new InvalidArgumentException(__('Can not have a display without a name'), 'name');

if (!v::stringType()->notEmpty()->validate($this->license))
            throw new InvalidArgumentException(__('Can not have a display without a hardware key'), 'license');

if ($this->wakeOnLanEnabled == 1 && $this->wakeOnLanTime == '')
            throw new InvalidArgumentException(__('Wake on Lan is enabled, but you have not specified a time to wake the display'), 'wakeonlan');

// Broadcast Address
        if ($this->broadCastAddress != '' && !v::ip()->validate($this->broadCastAddress))
            throw new InvalidArgumentException(__('BroadCast Address is not a valid IP Address'), 'broadCastAddress');

// CIDR
        if (!empty($this->cidr) && !v::numeric()->between(0, 32)->validate($this->cidr))
            throw new InvalidArgumentException(__('CIDR subnet mask is not a number within the range of 0 to 32.'), 'cidr');

// secureOn
        if ($this->secureOn != '') {
            $this->secureOn = strtoupper($this->secureOn);
            $this->secureOn = str_replace(":", "-", $this->secureOn);

if ((!preg_match("/([A-F0-9]{2}[-]){5}([0-9A-F]){2}/", $this->secureOn)) || (strlen($this->secureOn) != 17))
                throw new InvalidArgumentException(__('Pattern of secureOn-password is not "xx-xx-xx-xx-xx-xx" (x = digit or CAPITAL letter)'), 'secureOn');
        }

// Mac Address Changes
        if ($this->hasPropertyChanged('macAddress')) {
            // Mac address change detected
            $this->numberOfMacAddressChanges++;
            $this->lastChanged = time();
        }

// Lat/Long
        if (!empty($this->longitude) && !v::longitude()->validate($this->longitude))
            throw new InvalidArgumentException(__('The longitude entered is not valid.'), 'longitude');

if (!empty($this->latitude) && !v::latitude()->validate($this->latitude))
            throw new InvalidArgumentException(__('The latitude entered is not valid.'), 'latitude');

if ($this->bandwidthLimit !== null && !v::intType()->min(0)->validate($this->bandwidthLimit)) {
            throw new InvalidArgumentException(__('Bandwidth limit must be a whole number greater than 0.'), 'bandwidthLimit');
        }
    }

/**
     * Check if there is display slot available, returns true when there are display slots available, return false if there are no display slots available
     * @return boolean
     */
    public function isDisplaySlotAvailable()
    {
        $maxDisplays = $this->config->GetSetting('MAX_LICENSED_DISPLAYS');

// Check the number of licensed displays
        if ($maxDisplays > 0) {
            $this->getLog()->debug('Testing authorised displays against %d maximum. Currently authorised = %d, authorised = %d.', $maxDisplays, $this->currentlyLicensed, $this->licensed);

if ($this->currentlyLicensed != $this->licensed && $this->licensed == 1) {
                $countLicensed = $this->getStore()->select('SELECT COUNT(DisplayID) AS CountLicensed FROM display WHERE licensed = 1', []);

$this->getLog()->debug('There are %d authorised displays and we the maximum is %d', $countLicensed[0]['CountLicensed'], $maxDisplays);

if (intval($countLicensed[0]['CountLicensed']) + 1 > $maxDisplays) {
                    return false;
                }
            }
        }

return true;
    }

/**
     * Load
     * @throws NotFoundException
     */
    public function load()
    {
        if ($this->loaded)
            return;

// Load this displays group membership
        $this->displayGroups = $this->displayGroupFactory->getByDisplayId($this->displayId);

$this->loaded = true;
    }

/**
     * Save the media inventory status
     */
    public function saveMediaInventoryStatus()
    {
        try {
            $this->getStore()->updateWithDeadlockLoop('UPDATE `display` SET mediaInventoryStatus = :mediaInventoryStatus WHERE displayId = :displayId', [
                'mediaInventoryStatus' => $this->mediaInventoryStatus,
                'displayId' => $this->displayId
            ]);
        } catch (DeadlockException $deadlockException) {
            $this->getLog()->error('Media Inventory Status save failed due to deadlock');
        }
    }

/**
     * Save
     * @param array $options
     * @throws XiboException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'audit' => true,
            'checkDisplaySlotAvailability' => true
        ], $options);

$allowNotify = true;

if ($options['validate'])
            $this->validate();

if ($options['checkDisplaySlotAvailability']) {
            // Check if there are display slots available
            $maxDisplays = $this->config->GetSetting('MAX_LICENSED_DISPLAYS');

if (!$this->isDisplaySlotAvailable()) {
                throw new InvalidArgumentException(sprintf(__('You have exceeded your maximum number of authorised displays. %d'),
                    $maxDisplays), 'maxDisplays');
            }
        }

if ($this->displayId == null || $this->displayId == 0) {
            $this->add();

// Never notify on add (there is little point, we've only just added).
            $allowNotify = false;
        }
        else {
            $this->edit();
        }

if ($options['audit'])
            $this->getLog()->audit('Display', $this->displayId, 'Display Saved', $this->getChangedProperties());

// Trigger an update of all dynamic DisplayGroups
        if ($this->hasPropertyChanged('display') || $this->hasPropertyChanged('tags')) {
            foreach ($this->displayGroupFactory->getByIsDynamic(1) as $group) {
                /* @var DisplayGroup $group */
                $group->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);
                $group->save(['validate' => false, 'saveGroup' => false, 'manageDisplayLinks' => true, 'allowNotify' => $allowNotify]);
            }
        }
    }

/**
     * Delete
     * @throws XiboException
     */
    public function delete()
    {
        $this->load();

// Delete incidential references
        $this->getStore()->update('DELETE FROM `requiredfile` WHERE displayId = :displayId', ['displayId' => $this->displayId]);

// Remove our display from any groups it is assigned to
        foreach ($this->displayGroups as $displayGroup) {
            /* @var DisplayGroup $displayGroup */
            $displayGroup->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);
            $displayGroup->unassignDisplay($this);
            $displayGroup->save(['validate' => false, 'manageDynamicDisplayLinks' => false]);
        }

// Delete our display specific group
        $displayGroup = $this->displayGroupFactory->getById($this->displayGroupId);
        $displayGroup->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);
        $displayGroup->delete();

// Delete the display
        $this->getStore()->update('DELETE FROM `blacklist` WHERE displayId = :displayId', ['displayId' => $this->displayId]);
        $this->getStore()->update('DELETE FROM `display` WHERE displayId = :displayId', ['displayId' => $this->displayId]);

$this->getLog()->audit('Display', $this->displayId, 'Display Deleted', ['displayId' => $this->displayId]);
    }

private function add()
    {
        $this->displayId = $this->getStore()->insert('
            INSERT INTO display (display, auditingUntil, defaultlayoutid, license, licensed, lastAccessed, inc_schedule, email_alert, alert_timeout, clientAddress, xmrChannel, xmrPubKey, lastCommandSuccess, macAddress, lastChanged, lastWakeOnLanCommandSent, client_type, client_version, client_code, overrideConfig, newCmsAddress, newCmsKey, commercialLicence)
              VALUES (:display, :auditingUntil, :defaultlayoutid, :license, :licensed, :lastAccessed, :inc_schedule, :email_alert, :alert_timeout, :clientAddress, :xmrChannel, :xmrPubKey, :lastCommandSuccess, :macAddress, :lastChanged, :lastWakeOnLanCommandSent, :clientType, :clientVersion, :clientCode, :overrideConfig, :newCmsAddress, :newCmsKey, :commercialLicence)
        ', [
            'display' => $this->display,
            'auditingUntil' => 0,
            'defaultlayoutid' => $this->defaultLayoutId,
            'license' => $this->license,
            'licensed' => $this->licensed,
            'lastAccessed' => $this->lastAccessed,
            'inc_schedule' => 0,
            'email_alert' => 0,
            'alert_timeout' => 0,
            'clientAddress' => $this->clientAddress,
            'xmrChannel' => $this->xmrChannel,
            'xmrPubKey' => ($this->xmrPubKey === null) ? '' : $this->xmrPubKey,
            'lastCommandSuccess' => $this->lastCommandSuccess,
            'macAddress' => $this->macAddress,
            'lastChanged' => ($this->lastChanged === null) ? 0 : $this->lastChanged,
            'lastWakeOnLanCommandSent' => ($this->lastWakeOnLanCommandSent === null) ? 0 : $this->lastWakeOnLanCommandSent,
            'clientType' => $this->clientType,
            'clientVersion' => $this->clientVersion,
            'clientCode' => $this->clientCode,
            'overrideConfig' => ($this->overrideConfig == '') ? null : json_encode($this->overrideConfig),
            'newCmsAddress' => null,
            'newCmsKey' => null,
            'commercialLicence' => $this->commercialLicence
        ]);

$displayGroup = $this->displayGroupFactory->create();
        $displayGroup->displayGroup = $this->display;
        $displayGroup->tags = $this->tags;
        $displayGroup->setDisplaySpecificDisplay($this);

$this->getLog()->debug('Creating display specific group with userId ' . $displayGroup->userId);

$displayGroup->save();
    }

private function edit()
    {
        $this->getStore()->update('
            UPDATE display
                SET display = :display,
                    defaultlayoutid = :defaultLayoutId,
                    inc_schedule = :incSchedule,
                    license = :license,
                    licensed = :licensed,
                    auditingUntil = :auditingUntil,
                    email_alert = :emailAlert,
                    alert_timeout = :alertTimeout,
                    WakeOnLan = :wakeOnLanEnabled,
                    WakeOnLanTime = :wakeOnLanTime,
                    lastWakeOnLanCommandSent = :lastWakeOnLanCommandSent,
                    BroadCastAddress = :broadCastAddress,
                    SecureOn = :secureOn,
                    Cidr = :cidr,
                    GeoLocation = POINT(:latitude, :longitude),
                    displayprofileid = :displayProfileId,
                    lastaccessed = :lastAccessed,
                    loggedin = :loggedIn,
                    ClientAddress = :clientAddress,
                    MediaInventoryStatus = :mediaInventoryStatus,
                    client_type = :clientType,
                    client_version = :clientVersion,
                    client_code = :clientCode,
                    MacAddress = :macAddress,
                    LastChanged = :lastChanged,
                    NumberOfMacAddressChanges = :numberOfMacAddressChanges,
                    screenShotRequested = :screenShotRequested,
                    storageAvailableSpace = :storageAvailableSpace,
                    storageTotalSpace = :storageTotalSpace,
                    xmrChannel = :xmrChannel,
                    xmrPubKey = :xmrPubKey,
                    `lastCommandSuccess` = :lastCommandSuccess,
                    `deviceName` = :deviceName,
                    `timeZone` = :timeZone,
                    `overrideConfig` = :overrideConfig,
                    `newCmsAddress` = :newCmsAddress,
                    `newCmsKey` = :newCmsKey,
                    `orientation` = :orientation,
                    `resolution` = :resolution,
                    `commercialLicence` = :commercialLicence
             WHERE displayid = :displayId
        ', [
            'display' => $this->display,
            'defaultLayoutId' => $this->defaultLayoutId,
            'incSchedule' => $this->incSchedule,
            'license' => $this->license,
            'licensed' => $this->licensed,
            'auditingUntil' => ($this->auditingUntil == null) ? 0 : $this->auditingUntil,
            'emailAlert' => $this->emailAlert,
            'alertTimeout' => $this->alertTimeout,
            'wakeOnLanEnabled' => $this->wakeOnLanEnabled,
            'wakeOnLanTime' => $this->wakeOnLanTime,
            'lastWakeOnLanCommandSent' => $this->lastWakeOnLanCommandSent,
            'broadCastAddress' => $this->broadCastAddress,
            'secureOn' => $this->secureOn,
            'cidr' => $this->cidr,
            'latitude' => $this->latitude,
            'longitude' => $this->longitude,
            'displayProfileId' => ($this->displayProfileId == null) ? null : $this->displayProfileId,
            'lastAccessed' => $this->lastAccessed,
            'loggedIn' => $this->loggedIn,
            'clientAddress' => $this->clientAddress,
            'mediaInventoryStatus' => $this->mediaInventoryStatus,
            'clientType' => $this->clientType,
            'clientVersion' => $this->clientVersion,
            'clientCode' => $this->clientCode,
            'macAddress' => $this->macAddress,
            'lastChanged' => $this->lastChanged,
            'numberOfMacAddressChanges' => $this->numberOfMacAddressChanges,
            'screenShotRequested' => $this->screenShotRequested,
            'storageAvailableSpace' => $this->storageAvailableSpace,
            'storageTotalSpace' => $this->storageTotalSpace,
            'xmrChannel' => $this->xmrChannel,
            'xmrPubKey' => ($this->xmrPubKey === null) ? '' : $this->xmrPubKey,
            'lastCommandSuccess' => $this->lastCommandSuccess,
            'deviceName' => $this->deviceName,
            'timeZone' => $this->timeZone,
            'overrideConfig' => ($this->overrideConfig == '') ? null : json_encode($this->overrideConfig),
            'newCmsAddress' => $this->newCmsAddress,
            'newCmsKey' => $this->newCmsKey,
            'orientation' => $this->orientation,
            'resolution' => $this->resolution,
            'commercialLicence' => $this->commercialLicence,
            'displayId' => $this->displayId
        ]);

// Maintain the Display Group
        if ($this->hasPropertyChanged('display') || $this->hasPropertyChanged('description') || $this->hasPropertyChanged('tags') || $this->hasPropertyChanged('bandwidthLimit')) {
            $this->getLog()->debug('Display specific DisplayGroup properties need updating');

$displayGroup = $this->displayGroupFactory->getById($this->displayGroupId);
            $displayGroup->displayGroup = $this->display;
            $displayGroup->description = $this->description;
            $displayGroup->replaceTags($this->tags);
            $displayGroup->bandwidthLimit = $this->bandwidthLimit;
            $displayGroup->save(DisplayGroup::$saveOptionsMinimum);
        }
    }

/**
     * Get the Settings Profile for this Display
     * @param array $options
     * @return array
     * @throws \Xibo\Exception\XiboException
     */
    public function getSettings($options = [])
    {
        $options = array_merge([
            'displayOverride' => false
        ], $options);

return $this->setConfig($options);
    }

/**
     * @return array
     */
    public function getCommands()
    {
        if ($this->commands == null) {
            $displayProfile = $this->getDisplayProfile();

// Set any commands
            $this->commands = $displayProfile->commands;
        }

return $this->commands;
    }

/**
     * Get a particular setting
     * @param string $key
     * @param mixed $default
     * @param array $options
     * @return mixed
     * @throws NotFoundException
     */
    public function getSetting($key, $default = null, $options = [])
    {
        $options = array_merge([
            'displayOverride' => true,
            'displayOnly' => false
        ], $options);

$this->setConfig($options);

// Find
        $return = $default;
        if ($options['displayOnly']) {
            // Only get an option if set from the override config on this display
            foreach ($this->overrideConfig as $row) {
                if ($row['name'] == $key || $row['name'] == ucfirst($key)) {
                    $return = array_key_exists('value', $row) ? $row['value'] : ((array_key_exists('default', $row)) ? $row['default'] : $default);
                    break;
                }
            }
        } else if ($options['displayOverride']) {
            // Get the option from the combined array of config
            foreach ($this->combinedConfig as $row) {
                if ($row['name'] == $key || $row['name'] == ucfirst($key)) {
                    $return = array_key_exists('value', $row) ? $row['value'] : ((array_key_exists('default', $row)) ? $row['default'] : $default);
                    break;
                }
            }
        } else {
            // Get the option from the profile only
            foreach ($this->profileConfig as $row) {
                if ($row['name'] == $key || $row['name'] == ucfirst($key)) {
                    $return = array_key_exists('value', $row) ? $row['value'] : ((array_key_exists('default', $row)) ? $row['default'] : $default);
                    break;
                }
            }
        }

return $return;
    }

/**
     * Set the config array
     * @param array $options
     * @return array
     * @throws NotFoundException
     */
    private function setConfig($options = [])
    {
        $options = array_merge([
            'displayOverride' => false
        ], $options);

if ($this->profileConfig == null) {
            $this->load();

// Get the display profile
            $displayProfile = $this->getDisplayProfile();

// Merge in any overrides we have on our display.
            $this->profileConfig = $displayProfile->getProfileConfig();
            $this->combinedConfig = $this->mergeConfigs($this->profileConfig, $this->overrideConfig);
        }

return ($options['displayOverride']) ? $this->combinedConfig : $this->profileConfig;
    }

/**
     * Merge two configs
     * @param $default
     * @param $override
     * @return array
     */
    private function mergeConfigs($default, $override)
    {

foreach ($default as &$defaultItem) {
            for ($i = 0; $i < count($override); $i++) {
                if ($defaultItem['name'] == $override[$i]['name']) {

// For special json fields, we need to decode, merge, encode and save instead
                    if(in_array($defaultItem['name'], ['timers', 'pictureOptions', 'lockOptions']) && isset($defaultItem['value']) && isset($override[$i]['value'])) {

// Decode values
                        $defaultItemValueDecoded = json_decode($defaultItem['value'], true);
                        $overrideValueDecoded = json_decode($override[$i]['value'], true);

// Merge values, encode and save
                        $defaultItem['value'] = json_encode(array_merge($defaultItemValueDecoded, $overrideValueDecoded));
                        break;
                    } else {
                        // merge
                        $defaultItem = array_merge($defaultItem, $override[$i]);
                        break;
                    }
                    
                }
            }
        }

// Merge the remainder
        return $default;
    }

/**
     * @param PoolInterface $pool
     * @return int|null
     */
    public function getCurrentLayoutId($pool)
    {
        $item = $pool->getItem('/currentLayoutId/' . $this->displayId);

$data = $item->get();

if ($item->isHit()) {
            $this->currentLayoutId = $data;

try {
                $this->currentLayout = $this->layoutFactory->getById($this->currentLayoutId)->layout;
            }
            catch (NotFoundException $notFoundException) {
                // This is ok
            }
        } else {
            $this->getLog()->debug('Cache miss for setCurrentLayoutId on display ' . $this->display);
        }

return $this->currentLayoutId;
    }

/**
     * @param PoolInterface $pool
     * @param int $currentLayoutId
     * @return $this
     * @throws \Exception
     */
    public function setCurrentLayoutId($pool, $currentLayoutId)
    {
        // Cache it
        $this->getLog()->debug('Caching currentLayoutId with Pool');

$item = $pool->getItem('/currentLayoutId/' . $this->displayId);
        $item->set($currentLayoutId);
        $item->expiresAfter(new \DateInterval('P1W'));

$pool->saveDeferred($item);

return $this;
    }

/**
     * @param PoolInterface $pool
     * @return int|null
     */
    public function getCurrentScreenShotTime($pool)
    {
        $item = $pool->getItem('/screenShotTime/' . $this->displayId);

return $item->get();
    }

/**
     * @param PoolInterface $pool
     * @param string $date
     * @return $this
     * @throws \Exception
     */
    public function setCurrentScreenShotTime($pool, $date)
    {
        // Cache it
        $this->getLog()->debug('Caching currentLayoutId with Pool');

$item = $pool->getItem('/screenShotTime/' . $this->displayId);
        $item->set($date);
        $item->expiresAfter(new \DateInterval('P1W'));

$pool->saveDeferred($item);

return $this;
    }
}
PK�������qY�na0��������AuditLog.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (AuditLog.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class AuditLog
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class AuditLog implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Log Id")
     * @var int
     */
    public $logId;

/**
     * @SWG\Property(description="The Log Date")
     * @var int
     */
    public $logDate;

/**
     * @SWG\Property(description="The userId of the User that took this action")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="Message describing the action taken")
     * @var string
     */
    public $message;

/**
     * @SWG\Property(description="The effected entity")
     * @var string
     */
    public $entity;

/**
     * @SWG\Property(description="The effected entityId")
     * @var int
     */
    public $entityId;

/**
     * @SWG\Property(description="A JSON representation of the object after it was changed")
     * @var string
     */
    public $objectAfter;

/**
     * @SWG\Property(description="The User Name of the User that took this action")
     * @var string
     */
    public $userName;

namespace Xibo\Entity;

use Xibo\Exception\XiboException;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\SavedReportFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
* Class SavedReport
* @package Xibo\Entity
*
* @SWG\Definition()
*/
class SavedReport implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="Saved report ID")
     * @var int
     */
    public $savedReportId;

/**
     * @SWG\Property(description="Saved report name As")
     * @var string
     */
    public $saveAs;

/**
     * @SWG\Property(description="Report schedule Id of the saved report")
     * @var int
     */
    public $reportScheduleId;

/**
     * @SWG\Property(description="Report schedule name of the saved report")
     * @var string
     */
    public $reportScheduleName;

/**
     * @SWG\Property(description="Report name")
     * @var string
     */
    public $reportName;

/**
     * @SWG\Property(description="Saved report generated on")
     * @var string
     */
    public $generatedOn;

/**
     * @SWG\Property(description="The username of the User that owns this saved report")
     * @var string
     */
    public $owner;

/**
     * @SWG\Property(description="The ID of the User that owns this saved report")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="Media Id")
     * @var int
     */
    public $mediaId;

/**
     * @SWG\Property(description="Original name of the saved report media file")
     * @var string
     */
    public $originalFileName;

/**
     * @SWG\Property(description="Stored As")
     * @var string
     */
    public $storedAs;

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var SavedReportFactory
     */
    private $savedReportFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param MediaFactory $mediaFactory
     * @param SavedReportFactory $savedReportFactory
     */
    public function __construct($store, $log, $config, $mediaFactory, $savedReportFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->config = $config;
        $this->mediaFactory = $mediaFactory;
        $this->savedReportFactory = $savedReportFactory;
    }

/**
     * Add
     */
    private function add()
    {
        $this->savedReportId = $this->getStore()->insert('
            INSERT INTO `saved_report` (`saveAs`, `reportScheduleId`, `mediaId`, `generatedOn`, `userId`)
              VALUES (:saveAs, :reportScheduleId, :mediaId, :generatedOn, :userId)
        ', [
            'saveAs' => $this->saveAs,
            'reportScheduleId' => $this->reportScheduleId,
            'mediaId' => $this->mediaId,
            'generatedOn' => $this->generatedOn,
            'userId' => $this->userId
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $sql = '
          UPDATE `saved_report`
            SET `saveAs` = :saveAs,
                `reportScheduleId` = :reportScheduleId,
                `mediaId` = :mediaId,
                `generatedOn` = :generatedOn,
                `userId` = :userId
           WHERE savedReportId = :savedReportId
        ';

$params = [
            'saveAs' => $this->saveAs,
            'reportScheduleId' => $this->reportScheduleId,
            'mediaId' => $this->mediaId,
            'generatedOn' => $this->generatedOn,
            'userId' => $this->userId,
            'savedReportId' => $this->savedReportId,

];

$this->getStore()->update($sql, $params);
    }

/**
     * Delete
     * @throws XiboException
     */
    public function delete()
    {
        $this->load();

$this->getLog()->debug('Delete saved report: '.$this->saveAs.'. Generated on: '.$this->generatedOn);
        $this->getStore()->update('DELETE FROM `saved_report` WHERE `savedReportId` = :savedReportId', [
            'savedReportId' => $this->savedReportId
        ]);

// Update last saved report in report schedule
        $this->getLog()->debug('Update last saved report in report schedule');
        $this->getStore()->update('
        UPDATE `reportschedule` SET lastSavedReportId = ( SELECT MAX(`savedReportId`) FROM `saved_report` WHERE `reportScheduleId`= :reportScheduleId) 
        WHERE `reportScheduleId` = :reportScheduleId',
            [
            'reportScheduleId' => $this->reportScheduleId
            ]);
    }

/**
     * Load
     */
    public function load()
    {
        if ($this->loaded || $this->savedReportId == null)
            return;

$this->loaded = true;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->savedReportId;
    }

/**
     * Get Owner Id
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Save
     * @param array $options
     */
    public function save()
    {
        if ($this->savedReportId == null || $this->savedReportId == 0)
            $this->add();
        else
            $this->edit();
    }
}PK�������qY��Iv*)��*)����DayPart.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2012-2016 Spring Signage Ltd - http://www.springsignage.com
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\ConfigurationException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Factory\DayPartFactory;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DayPart
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DayPart implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Daypart")
     * @var int
     */
    public $dayPartId;
    public $name;
    public $description;
    public $isRetired;
    public $userId;

public $startTime;
    public $endTime;
    public $exceptions;

/**
     * @SWG\Property(description="A readonly flag determining whether this DayPart is always")
     * @var int
     */
    public $isAlways = 0;

/**
     * @SWG\Property(description="A readonly flag determining whether this DayPart is custom")
     * @var int
     */
    public $isCustom = 0;

private $timeHash;

/** @var  DateServiceInterface */
    private $dateService;

/** @var  ScheduleFactory */
    private $scheduleFactory;

/** @var DisplayGroupFactory */
    private $displayGroupFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var  LayoutFactory */
    private $layoutFactory;

/** @var  MediaFactory */
    private $mediaFactory;

/** @var  DayPartFactory */
    private $dayPartFactory;

/**
     * @param ScheduleFactory $scheduleFactory
     * @return $this
     */
    public function setScheduleFactory($scheduleFactory)
    {
        $this->scheduleFactory = $scheduleFactory;
        return $this;
    }

/**
     * @param DateServiceInterface $dateService
     * @return $this
     */
    public function setDateService($dateService)
    {
        $this->dateService = $dateService;
        return $this;
    }

return $this->dateService;
    }

/**
     * @param DisplayGroupFactory $displayGroupFactory
     * @param DisplayFactory $displayFactory
     * @param LayoutFactory $layoutFactory
     * @param MediaFactory $mediaFactory
     * @param ScheduleFactory $scheduleFactory
     * @param DayPartFactory $dayPartFactory
     * @return $this
     */
    public function setChildObjectDependencies($displayGroupFactory, $displayFactory, $layoutFactory, $mediaFactory, $scheduleFactory, $dayPartFactory)
    {
        $this->displayGroupFactory = $displayGroupFactory;
        $this->displayFactory = $displayFactory;
        $this->layoutFactory = $layoutFactory;
        $this->mediaFactory = $mediaFactory;
        $this->scheduleFactory = $scheduleFactory;
        $this->dayPartFactory = $dayPartFactory;
        return $this;
    }

/**
     * Calculate time hash
     * @return string
     */
    private function calculateTimeHash()
    {
        $hash = $this->startTime . $this->endTime;

foreach ($this->exceptions as $exception) {
            $hash .= $exception['day'] . $exception['start'] . $exception['end'];
        }

return md5($hash);
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->dayPartId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->userId = $ownerId;
    }

public function validate()
    {
        $this->getLog()->debug('Validating daypart ' . $this->name);

if (!v::stringType()->notEmpty()->validate($this->name))
            throw new InvalidArgumentException(__('Name cannot be empty'), 'name');

// Check the start/end times are in the correct format (H:i)
        if ((strlen($this->startTime) != 8 && strlen($this->startTime) != 5) || (strlen($this->endTime) != 8 && strlen($this->endTime) != 5))
            throw new InvalidArgumentException(__('Start/End time are empty or in an incorrect format'), 'start/end time');

foreach ($this->exceptions as $exception) {
            if ((strlen($exception['start']) != 8 && strlen($exception['start']) != 5) || (strlen($exception['end']) != 8 && strlen($exception['end']) != 5))
                throw new InvalidArgumentException(sprintf(__('Exception Start/End time for %s are empty or in an incorrect format'), $exception['day']), 'exception start/end time');
        }
    }

/**
     * Load
     * @return $this
     */
    public function load()
    {
        $this->timeHash = $this->calculateTimeHash();

return $this;
    }

/**
     * Save
     * @param array $options
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true
        ], $options);

if ($options['validate'])
            $this->validate();

if ($this->dayPartId == 0)
            $this->add();
        else {
            // Update
            $this->update();

// Compare the time hash with a new time hash to see if we need to update associated schedules
            if ($this->timeHash != $this->calculateTimeHash())
                $this->handleEffectedSchedules();
            else
                $this->getLog()->debug('Daypart hash identical, no need to update schedules. ' . $this->timeHash . ' vs ' . $this->calculateTimeHash());
        }
    }

/**
     * Delete
     */
    public function delete()
    {
        // Delete all events using this daypart
        $schedules = $this->scheduleFactory->getByDayPartId($this->dayPartId);

foreach ($schedules as $schedule) {
            $schedule->delete();
        }

// Delete the daypart
        $this->getStore()->update('DELETE FROM `daypart` WHERE dayPartId = :dayPartId', ['dayPartId' => $this->dayPartId]);
    }

/**
     * Add
     */
    private function add()
    {
        $this->dayPartId = $this->getStore()->insert('
            INSERT INTO `daypart` (`name`, `description`, `isRetired`, `userId`, `startTime`, `endTime`, `exceptions`)
              VALUES (:name, :description, :isRetired, :userId, :startTime, :endTime, :exceptions)
        ', [
            'name' => $this->name,
            'description' => $this->description,
            'isRetired' => $this->isRetired,
            'userId' => $this->userId,
            'startTime' => $this->startTime,
            'endTime' => $this->endTime,
            'exceptions' => json_encode(is_array($this->exceptions) ? $this->exceptions : [])
        ]);
    }

/**
     * Update
     */
    private function update()
    {
        $this->getStore()->update('
            UPDATE `daypart`
                SET `name` = :name,
                    `description` = :description,
                    `isRetired` = :isRetired,
                    `userId` = :userId,
                    `startTime` = :startTime,
                    `endTime` = :endTime,
                    `exceptions` = :exceptions
             WHERE `daypart`.dayPartId = :dayPartId
        ', [
            'dayPartId' => $this->dayPartId,
            'name' => $this->name,
            'description' => $this->description,
            'isRetired' => $this->isRetired,
            'userId' => $this->userId,
            'startTime' => $this->startTime,
            'endTime' => $this->endTime,
            'exceptions' => json_encode(is_array($this->exceptions) ? $this->exceptions : [])
        ]);
    }

/**
     * Handles schedules effected by an update
     */
    private function handleEffectedSchedules()
    {
        $now = time();

// Get all schedules that use this dayPart and exist after the current time.
        $schedules = $this->scheduleFactory->query(null, ['dayPartId' => $this->dayPartId, 'futureSchedulesFrom' => $now]);

$this->getLog()->debug('Daypart update effects ' . count($schedules) . ' schedules.');

foreach ($schedules as $schedule) {
            /** @var Schedule $schedule */
            $schedule
                ->setDisplayFactory($this->displayFactory)
                ->load();

// Is this schedule a recurring event?
            if ($schedule->recurrenceType != '' && $schedule->fromDt < $now) {
                $this->getLog()->debug('Schedule is for a recurring event which has already recurred');

// Split the scheduled event, adjusting only the recurring end date on the original event
                $newSchedule = clone $schedule;
                $schedule->recurrenceRange = $now;
                $schedule->save();

// Adjusting the fromdt on the new event
                $newSchedule->fromDt = $this->getDate()->parse()->addDay()->format('U');
                $newSchedule->save();
            } else {
                $this->getLog()->debug('Schedule is for a single event');

// Update just this single event to have the new date/time
                $schedule->save();
            }
        }
    }
}PK�������qY�h��]��]����WidgetOption.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (WidgetOption.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class WidgetOption
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class WidgetOption implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Widget ID that this Option belongs to")
     * @var int
     */
    public $widgetId;

/**
     * @SWG\Property(description="The option type, either attrib or raw")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="The option name")
     * @var string
     */
    public $option;

/**
     * @SWG\Property(description="The option value")
     * @var string
     */
    public $value;

public function __clone()
    {
        $this->widgetId = null;
    }

public function __toString()
    {
        if ($this->type == 'cdata') {
            return sprintf('%s WidgetOption %s', $this->type, $this->option);
        }
        else {
            return sprintf('%s WidgetOption %s with value %s', $this->type, $this->option, $this->value);
        }
    }

public function save()
    {
        $this->getLog()->debug('Saving ' . $this);

$this->getStore()->insert('
            INSERT INTO `widgetoption` (`widgetId`, `type`, `option`, `value`)
              VALUES (:widgetId, :type, :option, :value) ON DUPLICATE KEY UPDATE `value` = :value2
        ', array(
            'widgetId' => $this->widgetId,
            'type' => $this->type,
            'option' => $this->option,
            'value' => $this->value,
            'value2' => $this->value
        ));
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM `widgetoption` WHERE `widgetId` = :widgetId AND `option` = :option', array(
            'widgetId' => $this->widgetId, 'option' => $this->option)
        );
    }
}PK�������qYo��-��������ApplicationScope.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (ApplicationScope.php)
 */

namespace Xibo\Entity;

use Xibo\Exception\AccessDeniedException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class ApplicationScope
 * @package Xibo\Entity
 */
class ApplicationScope implements \JsonSerializable
{
    use EntityTrait;

/**
     * @var
     */
    public $id;

/**
     * @var
     */
    public $description;

/**
     * Get Id
     * @return string
     */
    public function getId()
    {
        return $this->id;
    }

/**
     * Check whether this scope has permission for this route
     * @param $method
     * @param $route
     */
    public function checkRoute($method, $route)
    {
        $route = $this->getStore()->select('
            SELECT *
              FROM `oauth_scope_routes`
             WHERE scopeId = :scope
              AND method = :method
              AND route = :route
        ', [
            'scope' => $this->getId(),
            'method' => $method,
            'route' => $route
        ]);

if (count($route) <= 0)
            throw new AccessDeniedException(__('Access to this route is denied for this scope'));
    }
}PK�������qY��YX�	���	����RequiredFile.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Nonce.php)
 */

namespace Xibo\Entity;

use Xibo\Exception\DeadlockException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class RequiredFile
 * @package Xibo\Entity
 */
class RequiredFile implements \JsonSerializable
{
    use EntityTrait;
    public $rfId;
    public $displayId;
    public $type;
    public $itemId;
    public $size = 0;
    public $path;
    public $bytesRequested = 0;
    public $complete = 0;
    public $released = 1;

/**
     * Save
     * @return $this
     */
    public function save()
    {
        if ($this->rfId == null)
            $this->add();
        else if ($this->hasPropertyChanged('bytesRequested') || $this->hasPropertyChanged('complete')) {
            $this->edit();
        }

return $this;
    }

/**
     * Add
     */
    private function add()
    {
        $this->rfId = $this->store->insert('
            INSERT INTO `requiredfile` (`displayId`, `type`, `itemId`, `bytesRequested`, `complete`, `size`, `path`, `released`)
              VALUES (:displayId, :type, :itemId, :bytesRequested, :complete, :size, :path, :released)
        ', [
            'displayId' => $this->displayId,
            'type' => $this->type,
            'itemId' => $this->itemId,
            'bytesRequested' => $this->bytesRequested,
            'complete' => $this->complete,
            'size' => $this->size,
            'path' => $this->path,
            'released' => $this->released
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        try {
            $this->store->updateWithDeadlockLoop('
            UPDATE `requiredfile` SET complete = :complete, bytesRequested = :bytesRequested
             WHERE rfId = :rfId
        ', [
                'rfId' => $this->rfId,
                'bytesRequested' => $this->bytesRequested,
                'complete' => $this->complete
            ]);
        } catch (DeadlockException $deadlockException) {
            $this->getLog()->error('Failed to update bytes requested on ' . $this->rfId . ' due to deadlock');
        }
    }
}PK�������qY����,��,����DisplayEvent.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (DisplayEvent.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DisplayEvent
 * @package Xibo\Entity
 */
class DisplayEvent implements \JsonSerializable
{
    use EntityTrait;

public $displayEventId;
    public $displayId;
    public $eventDate;
    public $start;
    public $end;

public function save()
    {
        if ($this->displayEventId == null)
            $this->add();
        else
            $this->edit();
    }

private function add()
    {
        $this->displayEventId = $this->getStore()->insert('
            INSERT INTO `displayevent` (eventDate, start, end, displayID)
              VALUES (:eventDate, :start, :end, :displayId)
        ', [
            'eventDate' => time(),
            'start' => $this->start,
            'end' => $this->end,
            'displayId' => $this->displayId
        ]);
    }

private function edit()
    {
        $this->getStore()->update('UPDATE `displayevent` SET `end` = :end WHERE statId = :statId', [
            'displayevent' => $this->displayEventId, 'end' => $this->end
        ]);
    }

/**
     * Record the display coming online
     * @param $displayId
     */
    public function displayUp($displayId)
    {
        $this->getStore()->update('UPDATE `displayevent` SET `end` = :toDt WHERE displayId = :displayId AND `end` IS NULL', [
            'toDt' => time(),
            'displayId' => $displayId
        ]);
    }
}PK�������qYe&|��F���F����Campaign.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015-2018 Spring Signage Ltd
 *
 * This file (Campaign.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Factory\TagFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Campaign
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Campaign implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Campaign Id")
     * @var int
     */
    public $campaignId;

/**
     * @SWG\Property(description="The userId of the User that owns this Campaign")
     * @var int
     */
    public $ownerId;

/**
     * @SWG\Property(description="The name of the Campaign")
     * @var string
     */
    public $campaign;

/**
     * @SWG\Property(description="A 0|1 flag to indicate whether this is a Layout specific Campaign or not.")
     * @var int
     */
    public $isLayoutSpecific = 0;

/**
     * @SWG\Property(description="The number of Layouts associated with this Campaign")
     * @var int
     */
    public $numberLayouts;

/**
     * @SWG\Property(description="The total duration of the campaign (sum of layout's durations)")
     * @var int
     */
    public $totalDuration;

public $tags = [];
    public $tagValues;

/**
     * @var Layout[]
     */
    public $layouts = [];

/**
     * @var Permission[]
     */
    private $permissions = [];

/**
     * @var Schedule[]
     */
    private $events = [];
    
    // Private
    private $unassignTags = [];

/** @var bool Have the Layout assignments changed? */
    private $layoutAssignmentsChanged = false;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;
    
    /**
     * @var TagFactory
     */
    private $tagFactory;

/**
     * @var ScheduleFactory
     */
    private $scheduleFactory;

/**
     * @var DisplayFactory
     */
    private $displayFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param PermissionFactory $permissionFactory
     * @param ScheduleFactory $scheduleFactory
     * @param DisplayFactory $displayFactory
     * @param TagFactory $tagFactory
     */
    public function __construct($store, $log, $permissionFactory, $scheduleFactory, $displayFactory, $tagFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->permissionFactory = $permissionFactory;
        $this->scheduleFactory = $scheduleFactory;
        $this->displayFactory = $displayFactory;
        $this->tagFactory = $tagFactory;
    }

/**
     * Set Child Object Depencendies
     *  must be set before calling Load with all objects
     * @param LayoutFactory $layoutFactory
     * @return $this
     */
    public function setChildObjectDependencies($layoutFactory)
    {
        $this->layoutFactory = $layoutFactory;
        return $this;
    }

public function __clone()
    {
        $this->campaignId = null;
    }

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('CampaignId %d, Campaign %s, LayoutSpecific %d', $this->campaignId, $this->campaign, $this->isLayoutSpecific);
    }

/**
     * Get the Id
     * @return int
     */
    public function getId()
    {
        return $this->campaignId;
    }

/**
     * Get the OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     */
    public function setOwner($ownerId)
    {
        $this->ownerId = $ownerId;
    }

/**
     * @param array $options
     * @throws \Xibo\Exception\NotFoundException
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadPermissions' => true,
            'loadLayouts' => true,
            'loadTags' => true,
            'loadEvents' => true
        ], $options);
        
        // If we are already loaded, then don't do it again
        if ($this->campaignId == null || $this->loaded)
            return;

if ($this->layoutFactory == null)
            throw new \RuntimeException('Cannot load campaign with all objects without first calling setChildObjectDependencies');

// Permissions
        if ($options['loadPermissions'])
            $this->permissions = $this->permissionFactory->getByObjectId('Campaign', $this->campaignId);

// Layouts
        if ($options['loadLayouts'])
            $this->layouts = $this->layoutFactory->getByCampaignId($this->campaignId, false);
            
        // Load all tags
        if ($options['loadTags'])
            $this->tags = $this->tagFactory->loadByCampaignId($this->campaignId);

// Events
        if ($options['loadEvents'])
            $this->events = $this->scheduleFactory->getByCampaignId($this->campaignId);

$this->loaded = true;
    }

/**
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->campaign))
            throw new InvalidArgumentException(__('Name cannot be empty'), 'name');
    }
    
    
    /**
     * Does the campaign have the provided tag?
     * @param $searchTag
     * @return bool
     * @throws NotFoundException
     */
    public function hasTag($searchTag)
    {
        $this->load();

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            if ($tag->tag == $searchTag)
                return true;
        }

return false;
    }

/**
     * Assign Tag
     * @param Tag $tag
     * @return $this
     * @throws NotFoundException
     */
    public function assignTag($tag)
    {
        $this->load();

if ($this->tags != [$tag]) {

if (!in_array($tag, $this->tags)) {
                $this->tags[] = $tag;
            }
        } else {
            $this->getLog()->debug('No Tags to assign');
        }

return $this;
    }

/**
     * Unassign tag
     * @param Tag $tag
     * @return $this
     * @throws NotFoundException
     */
    public function unassignTag($tag)
    {
        $this->load();

$this->tags = array_udiff($this->tags, [$tag], function($a, $b) {
            /* @var Tag $a */
            /* @var Tag $b */
            return $a->tagId - $b->tagId;
        });

$this->unassignTags[] = $tag;

$this->getLog()->debug('Tags after removal %s', json_encode($this->tags));

return $this;
    }

/**
     * @param array[Tag] $tags
     */
    public function replaceTags($tags = [])
    {
        if (!is_array($this->tags) || count($this->tags) <= 0)
            $this->tags = $this->tagFactory->loadByCampaignId($this->campaignId);

$this->getLog()->debug('Tags to be removed: %s', json_encode($this->unassignTags));

// Replace the arrays
            $this->tags = $tags;

$this->getLog()->debug('Tags remaining: %s', json_encode($this->tags));
        } else {
            $this->getLog()->debug('Tags were not changed');
        }
    }

/**
     * Save this Campaign
     * @param array $options
     * @throws InvalidArgumentException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'notify' => true,
            'collectNow' => true,
            'saveTags' => true
        ], $options);

$this->getLog()->debug('Saving ' . $this);

if ($options['validate'])
            $this->validate();

if ($this->campaignId == null || $this->campaignId == 0) {
            $this->add();
            $this->loaded = true;
        }
        else
            $this->update();

if ($options['saveTags']) {
            // Save the tags
            if (is_array($this->tags)) {
                foreach ($this->tags as $tag) {
                    /* @var Tag $tag */

$this->getLog()->debug('Assigning tag ' . $tag->tag);

$tag->assignCampaign($this->campaignId);
                    $tag->save();
                }
            }

$tag->unassignCampaign($this->campaignId);
                    $tag->save();
                }
            }
        }

if ($this->loaded) {
            // Manage assignments
            $this->manageAssignments();
        }

// Notify anyone interested of the changes
        $this->notify($options);
    }

/**
     * Delete Campaign
     * @throws NotFoundException
     */
    public function delete()
    {
        $this->load();

// Unassign all Layouts
        $this->layouts = [];
        $this->unlinkLayouts();

// Delete all permissions
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->delete();
        }
        
        // Unassign all Tags
        foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tag->unassignCampaign($this->campaignId);
            $tag->save();
        }

// Notify anyone interested of the changes
        // we do this before we delete from the DB (otherwise notify won't find anything)
        $this->notify();

// Delete all events
        foreach ($this->events as $event) {
            /* @var Schedule $event */
            $event->setDisplayFactory($this->displayFactory);
            $event->delete();
        }

// Delete the Actual Campaign
        $this->getStore()->update('DELETE FROM `campaign` WHERE CampaignID = :campaignId', ['campaignId' => $this->campaignId]);
    }

/**
     * Assign Layout
     * @param Layout $layout
     * @throws NotFoundException
     */
    public function assignLayout($layout)
    {
        $this->load();

$layout->displayOrder = ($layout->displayOrder == null || $layout->displayOrder == 0) ? count($this->layouts) + 1 : $layout->displayOrder;

$found = false;
        foreach ($this->layouts as $existingLayout) {
            if ($existingLayout->getId() === $layout->getId() && $existingLayout->displayOrder === $layout->displayOrder) {
                $found = true;
                break;
            }
        }

if (!$found) {
            $this->getLog()->debug('Layout assignment doesnt exist, adding it. ' . $layout . ', display order ' . $layout->displayOrder);
            $this->layoutAssignmentsChanged = true;
            $this->layouts[] = $layout;
        }
    }

/**
     * Unassign Layout
     * @param Layout $layout
     * @param bool $unassignCompletely
     * @throws NotFoundException
     */
    public function unassignLayout($layout, $unassignCompletely = false)
    {
        $this->load();

$countBefore = count($this->layouts);
        $this->getLog()->debug('Unassigning Layout, count before assign = ' . $countBefore);

$found = false;
        $existingKeys = [];

foreach ($this->layouts as $key => $existing) {

/** @var Layout $existing */
            $this->getLog()->debug('Comparing existing [' . $existing->layoutId . ', ' . $existing->displayOrder . '] with unassign [' . $layout->layoutId . ', ' . $layout->displayOrder . '].');

if (!$unassignCompletely) {
                if ($layout->displayOrder == null) {
                    if ($existing->getId() == $layout->getId()) {
                        $found = true;
                        $existingKeys[] = $key;
                        break;
                    }
                } else {
                    if ($existing->getId() == $layout->getId() && $existing->displayOrder == $layout->displayOrder) {
                        $found = true;
                        $existingKeys[] = $key;
                        break;
                    }
                }
            } else {
                // we came here from Layout delete, make sure to unassign all occurrences of that Layout from the campaign
                // https://github.com/xibosignage/xibo/issues/1960
                if ($existing->getId() == $layout->getId()) {
                    $found = true;
                    $existingKeys[] = $key;
                }
            }
        }

if ($found) {
            foreach ($existingKeys as $existingKey) {
                $this->getLog()->debug('Removing item at key ' . $existingKey);
                unset($this->layouts[$existingKey]);
            }
        }

$countAfter = count($this->layouts);
        $this->getLog()->debug('Count after unassign ' . $countAfter);

if ($countBefore !== $countAfter)
            $this->layoutAssignmentsChanged = true;
    }

/**
     * Is the provided layout already assigned to this campaign
     * @param Layout $checkLayout
     * @return bool
     * @throws XiboException
     */
    public function isLayoutAssigned($checkLayout)
    {
        $assigned = false;

$this->load();

foreach ($this->layouts as $layout) {
            if ($layout->layoutId === $checkLayout->layoutId) {
                $assigned = true;
                break;
            }
        }

return $assigned;
    }

private function add()
    {
        $this->campaignId = $this->getStore()->insert('INSERT INTO `campaign` (Campaign, IsLayoutSpecific, UserId) VALUES (:campaign, :isLayoutSpecific, :userId)', array(
            'campaign' => $this->campaign,
            'isLayoutSpecific' => $this->isLayoutSpecific,
            'userId' => $this->ownerId
        ));
    }

private function update()
    {
        $this->getStore()->update('UPDATE `campaign` SET campaign = :campaign, userId = :userId WHERE CampaignID = :campaignId', [
            'campaignId' => $this->campaignId,
            'campaign' => $this->campaign,
            'userId' => $this->ownerId
        ]);
    }

/**
     * Manage the assignments
     */
    private function manageAssignments()
    {
        if ($this->layoutAssignmentsChanged) {
            $this->getLog()->debug('Managing Assignments on ' . $this);
            $this->unlinkLayouts();
            $this->linkLayouts();
        } else {
            $this->getLog()->debug('Assignments have not changed on ' . $this);
        }
    }

/**
     * Link Layout
     */
    private function linkLayouts()
    {
        // Don't do anything if we don't have any layouts
        if (count($this->layouts) <= 0)
            return;

// Sort the layouts by their display order
        usort($this->layouts, function($a, $b) {
            /** @var Layout $a */
            /** @var Layout $b */
            if ($a->displayOrder === null)
                return 1;

if ($a->displayOrder === $b->displayOrder)
                return 0;

return ($a->displayOrder < $b->displayOrder) ? -1 : 1;
        });

// Update the layouts, in order to have display order 1 to n
        $i = 0;
        $sql = 'INSERT INTO `lkcampaignlayout` (CampaignID, LayoutID, DisplayOrder) VALUES ';
        $params = [];

foreach ($this->layouts as $layout) {
            $i++;
            $layout->displayOrder = $i;

$sql .= '(:campaignId_' . $i . ', :layoutId_' . $i . ', :displayOrder_' . $i . '),';
            $params['campaignId_' . $i] = $this->campaignId;
            $params['layoutId_' . $i] = $layout->layoutId;
            $params['displayOrder_' . $i] = $layout->displayOrder;
        }

$sql = rtrim($sql, ',');

$this->getStore()->update($sql, $params);
    }

/**
     * Unlink Layout
     */
    private function unlinkLayouts()
    {
        // Delete all the links
        $this->getStore()->update('DELETE FROM `lkcampaignlayout` WHERE campaignId = :campaignId', ['campaignId' => $this->campaignId]);
    }

/**
     * Notify displays of this campaign change
     * @param array $options
     */
    private function notify($options = [])
    {
        $options = array_merge([
            'notify' => true,
            'collectNow' => true,
        ], $options);

// Do we notify?
        if ($options['notify']) {
            $this->getLog()->debug('CampaignId ' . $this->campaignId . ' wants to notify.');

$notify = $this->displayFactory->getDisplayNotifyService();

// Should we collect immediately
            if ($options['collectNow'])
                $notify->collectNow();

// Notify
            $notify->notifyByCampaignId($this->campaignId);
        }
    }
}
PK�������qYY���?��?��
��Region.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (Region.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;

use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\RegionFactory;
use Xibo\Factory\RegionOptionFactory;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Region
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Region implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this region")
     * @var int
     */
    public $regionId;

/**
     * @SWG\Property(description="The Layout ID this region belongs to")
     * @var int
     */
    public $layoutId;

/**
     * @SWG\Property(description="The userId of the User that owns this Region")
     * @var int
     */
    public $ownerId;

/**
     * @SWG\Property(description="The name of this Region")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="Width of the region")
     * @var double
     */
    public $width;

/**
     * @SWG\Property(description="Height of the Region")
     * @var double
     */
    public $height;

/**
     * @SWG\Property(description="The top coordinate of the Region")
     * @var double
     */
    public $top;

/**
     * @SWG\Property(description="The left coordinate of the Region")
     * @var double
     */
    public $left;

/**
     * @SWG\Property(description="The z-index of the Region to control Layering")
     * @var int
     */
    public $zIndex;

/**
     * @SWG\Property(description="An array of Region Options")
     * @var RegionOption[]
     */
    public $regionOptions = [];

/**
     * @SWG\Property(description="An array of Permissions")
     * @var Permission[]
     */
    public $permissions = [];

/**
     * @var int
     * @SWG\Property(
     *  description="A read-only estimate of this Regions's total duration in seconds. This is valid when the parent layout status is 1 or 2."
     * )
     */
    public $duration;

/**
     * Temporary Id used during import/upgrade
     * @var string read only string
     */
    public $tempId = null;

/**
     * @var Playlist|null
     * @SWG\Property(
     *   description="This Regions Playlist - null if getPlaylist() has not been called."
     * )
     */
    public $regionPlaylist = null;

//<editor-fold desc="Factories and Dependencies">
    /**  @var DateServiceInterface */
    private $dateService;

/**
     * @var RegionFactory
     */
    private $regionFactory;

/**
     * @var RegionOptionFactory
     */
    private $regionOptionFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var PlaylistFactory
     */
    private $playlistFactory;
    //</editor-fold>

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param DateServiceInterface $date
     * @param RegionFactory $regionFactory
     * @param PermissionFactory $permissionFactory
     * @param RegionOptionFactory $regionOptionFactory
     * @param PlaylistFactory $playlistFactory
     */
    public function __construct($store, $log, $date, $regionFactory, $permissionFactory, $regionOptionFactory, $playlistFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->dateService = $date;
        $this->regionFactory = $regionFactory;
        $this->permissionFactory = $permissionFactory;
        $this->regionOptionFactory = $regionOptionFactory;
        $this->playlistFactory = $playlistFactory;
    }

/**
     * Clone this object
     */
    public function __clone()
    {
        // Clear the regionId, clone the Playlist
        $this->regionId = null;
        $this->hash = null;
        $this->permissions = [];

$this->regionPlaylist = clone $this->regionPlaylist;

$this->regionOptions = array_map(function ($object) { return clone $object; }, $this->regionOptions);
    }

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('Region %s - %d x %d (%d, %d). RegionId = %d, LayoutId = %d. OwnerId = %d. Duration = %d', $this->name, $this->width, $this->height, $this->top, $this->left, $this->regionId, $this->layoutId, $this->ownerId, $this->duration);
    }

/**
     * @return string
     */
    private function hash()
    {
        return md5($this->name . $this->ownerId . $this->width . $this->height . $this->top . $this->left . $this->regionId . $this->zIndex . $this->duration);
    }

/**
     * Get the Id
     * @return int
     */
    public function getId()
    {
        return $this->regionId;
    }

/**
     * Get the OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->ownerId;
    }

/**
     * Sets the Owner
     * @param int $ownerId
     * @param bool $cascade Cascade ownership change down to Playlist records
     * @throws XiboException
     */
    public function setOwner($ownerId, $cascade = false)
    {
        $this->load();

$this->ownerId = $ownerId;

if ($cascade) {
            $playlist = $this->getPlaylist();
            $playlist->setOwner($ownerId);
        }
    }

/**
     * Get Option
     * @param string $option
     * @return RegionOption
     * @throws XiboException
     */
    public function getOption($option)
    {
        $this->load();

foreach ($this->regionOptions as $regionOption) {
            /* @var RegionOption $regionOption */
            if ($regionOption->option == $option)
                return $regionOption;
        }

$this->getLog()->debug('RegionOption ' . $option . ' not found');

throw new NotFoundException('Region Option not found');
    }

/**
     * Get Region Option Value
     * @param string $option
     * @param mixed $default
     * @return mixed
     * @throws XiboException
     */
    public function getOptionValue($option, $default = null)
    {
        $this->load();

try {
            $regionOption = $this->getOption($option);
            return $regionOption->value;
        }
        catch (NotFoundException $e) {
            return $default;
        }
    }

/**
     * Set Region Option Value
     * @param string $option
     * @param mixed $value
     * @throws XiboException
     */
    public function setOptionValue($option, $value)
    {
        try {
            $this->getOption($option)->value = $value;
        }
        catch (NotFoundException $e) {
            $this->regionOptions[] = $this->regionOptionFactory->create($this->regionId, $option, $value);
        }
    }

/**
     * @param array $options
     * @return Playlist
     * @throws NotFoundException
     */
    public function getPlaylist($options = [])
    {
        if ($this->regionPlaylist === null) {
            $this->regionPlaylist = $this->playlistFactory->getByRegionId($this->regionId)->load($options);
        }

return $this->regionPlaylist;
    }

/**
     * Load
     * @param array $options
     * @throws XiboException
     */
    public function load($options = [])
    {
        if ($this->loaded || $this->regionId == 0)
            return;

$options = array_merge([
            'loadPlaylists' => false
        ], $options);

$this->getLog()->debug('Load Region with ' . json_encode($options));

// Load permissions
        $this->permissions = $this->permissionFactory->getByObjectId(get_class(), $this->regionId);

// Get region options
        $this->regionOptions = $this->regionOptionFactory->getByRegionId($this->regionId);

// Load the Playlist?
        if ($options['loadPlaylists']) {
            $this->getPlaylist($options);
        }

$this->hash = $this->hash();
        $this->loaded = true;
    }

/**
     * Validate the region
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if ($this->width <= 0 || $this->height <= 0)
            throw new InvalidArgumentException(__('The Region dimensions cannot be empty or negative'), 'width/height');

// Check zindex is positive
        if ($this->zIndex < 0)
            throw new InvalidArgumentException(__('Layer must be 0 or a positive number'), 'zIndex');
    }

/**
     * Save
     * @param array $options
     * @throws XiboException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'saveRegionOptions' => true,
            'validate' => true,
            'audit' => true,
            'notify' => true
        ], $options);

$this->getLog()->debug('Saving ' . $this . '. Options = ' . json_encode($options, JSON_PRETTY_PRINT));

if ($options['validate'])
            $this->validate();

if ($options['audit']) {
            // get the layout specific campaignId
            $campaignId = 0;
            $sql = 'SELECT campaign.campaignId FROM layout INNER JOIN lkcampaignlayout on layout.layoutId = lkcampaignlayout.layoutId INNER JOIN campaign ON campaign.campaignId = lkcampaignlayout.campaignId WHERE campaign.isLayoutSpecific = 1 AND layout.layoutId = :layoutId';
            $params = ['layoutId' => $this->layoutId];
            $results = $this->store->select($sql, $params);
            foreach ($results as $row) {
                $campaignId = $row['campaignId'];
            }
        }

if ($this->regionId == null || $this->regionId == 0) {
            // We are adding
            $this->add();

// Add and save a region specific playlist
            if ($this->regionPlaylist === null) {
                $this->regionPlaylist = $this->playlistFactory->create($this->name, $this->ownerId, $this->regionId);
            } else {
                // assert the region id
                $this->regionPlaylist->regionId = $this->regionId;
                $this->regionPlaylist->setOwner($this->ownerId);
            }
            $this->regionPlaylist->save();

// Audit
            if ($options['audit']) {
                $this->audit($this->regionId, 'Added', ['regionId' => $this->regionId, 'campaignId' => $campaignId, 'details' => (string)$this]);
            }
        }
        else if ($this->hash != $this->hash()) {
            $this->update();

// There are 3 cases that we need to consider
            // 1 - Saving direct edit of region properties, $this->regionPlaylist will be null, as such we load it from database.
            // 2 - Saving whole Layout without changing ownership, $this->regionPlaylist will be populated including widgets property, we do not need to save widgets, load from database,
            // 3 - Saving whole Layout and changing the ownership (reassignAll or setOwner on Layout), in this case, we need to save widgets to cascade the ownerId change, don't load from database
            // case 3 due to - https://github.com/xibosignage/xibo/issues/2061
            $regionPlaylist = $this->playlistFactory->getByRegionId($this->regionId);

if ($this->regionPlaylist == null || $this->ownerId == $regionPlaylist->ownerId) {
                $this->regionPlaylist = $regionPlaylist;
            }

$this->regionPlaylist->name = $this->name;
            $this->regionPlaylist->save();

if ($options['audit']) {
                $change = $this->getChangedProperties();
                $change['campaignId'][] = $campaignId;
                $this->audit($this->regionId, 'Saved', $change);
            }
        }

if ($options['saveRegionOptions']) {
            // Save all Options
            foreach ($this->regionOptions as $regionOption) {
                /* @var RegionOption $regionOption */
                // Assert the regionId
                $regionOption->regionId = $this->regionId;
                $regionOption->save();
            }
        }
    }

/**
     * Delete Region
     * @param array $options
     * @throws XiboException
     */
    public function delete($options = [])
    {
        $options = array_merge([
            'notify' => true
        ], $options);

// We must ensure everything is loaded before we delete
        if ($this->hash == null)
            $this->load();

$this->getLog()->debug('Deleting ' . $this);

// Delete Permissions
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->deleteAll();
        }

// Delete all region options
        foreach ($this->regionOptions as $regionOption) {
            /* @var RegionOption $regionOption */
            $regionOption->delete();
        }

// Delete the region specific playlist
        $this->getPlaylist()->delete(['regionDelete' => true]);

// Delete this region
        $this->getStore()->update('DELETE FROM `region` WHERE regionId = :regionId', array('regionId' => $this->regionId));

$this->getLog()->audit('Region', $this->regionId, 'Region Deleted', ['regionId' => $this->regionId, 'layoutId' => $this->layoutId]);

// Notify Layout
        if ($options['notify'])
            $this->notifyLayout();
    }

/**
     * Add
     */
    private function add()
    {
        $this->getLog()->debug('Adding region to LayoutId ' . $this->layoutId);

$sql = '
            INSERT INTO `region` (`layoutId`, `ownerId`, `name`, `width`, `height`, `top`, `left`, `zIndex`) 
              VALUES (:layoutId, :ownerId, :name, :width, :height, :top, :left, :zIndex)
        ';

$this->regionId = $this->getStore()->insert($sql, array(
            'layoutId' => $this->layoutId,
            'ownerId' => $this->ownerId,
            'name' => $this->name,
            'width' => $this->width,
            'height' => $this->height,
            'top' => $this->top,
            'left' => $this->left,
            'zIndex' => $this->zIndex
        ));
    }

/**
     * Update
     */
    private function update()
    {
        $this->getLog()->debug('Editing ' . $this);

$sql = '
          UPDATE `region` SET
            `ownerId` = :ownerId,
            `name` = :name,
            `width` = :width,
            `height` = :height,
            `top` = :top,
            `left` = :left,
            `zIndex` = :zIndex,
            `duration` = :duration
           WHERE `regionId` = :regionId
        ';

$this->getStore()->update($sql, array(
            'ownerId' => $this->ownerId,
            'name' => $this->name,
            'width' => $this->width,
            'height' => $this->height,
            'top' => $this->top,
            'left' => $this->left,
            'zIndex' => $this->zIndex,
            'duration' => $this->duration,
            'regionId' => $this->regionId
        ));
    }

/**
     * Notify the Layout (set to building)
     */
    public function notifyLayout()
    {
        $this->getStore()->update('
            UPDATE `layout` SET `status` = 3, `modifiedDT` = :modifiedDt WHERE layoutId = :layoutId
        ', [
            'layoutId' => $this->layoutId,
            'modifiedDt' => $this->dateService->getLocalDate()
        ]);
    }
}PK�������qY�a+Db��Db����Tag.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Factory\TagFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Tag
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Tag implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Tag ID")
     * @var int
     */
    public $tagId;

/**
     * @SWG\Property(description="The Tag Name")
     * @var string
     */
    public $tag;

/**
     * @SWG\Property(description="Flag, whether the tag is a system tag")
     * @var int
     */
    public $isSystem = 0;

/**
     * @SWG\Property(description="Flag, whether the tag requires additional values")
     * @var int
     */
    public $isRequired = 0;

/**
     * @SWG\Property(description="An array of options assigned to this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $options;

/**
     * @SWG\Property(description="An array of layoutID and values pairs with this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $layouts = [];

/**
     * @SWG\Property(description="An array of playlistIDs and values with this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $playlists = [];
    
    /**
     * @SWG\Property(description="An array of campaignIDs and values with this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $campaigns = [];

/**
     * @SWG\Property(description="An array of mediaIds and values with this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $medias = [];

/**
     * @SWG\Property(description="An array of displayGroupIds and values with this Tag", @SWG\Items(type="string"))
     * @var array
     */
    public $displayGroups = [];

/**
     * @SWG\Property(description="The Tag Value")
     * @var string
     */
    public $value = null;

private $originalLayouts = [];
    private $originalPlaylists = [];
    private $originalMedias = [];
    private $originalCampaigns = [];
    private $originalDisplayGroups = [];

/** @var  TagFactory */
    private $tagFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param TagFactory $tagFactory
     */
    public function __construct($store, $log, $tagFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->tagFactory = $tagFactory;
    }

public function __clone()
    {
        $this->tagId = null;
    }

/**
     * @throws InvalidArgumentException
     * @throws DuplicateEntityException
     */
    public function validate()
    {
        // Name Validation
        if (strlen($this->tag) > 50 || strlen($this->tag) < 1) {
            throw new InvalidArgumentException(__("Tag must be between 1 and 50 characters"), 'tag');
        }

// Check for duplicates
        $duplicates = $this->tagFactory->query(null, [
            'tagExact' => $this->tag,
            'notTagId' => $this->tagId,
            'disableUserCheck' => 1
        ]);

if (count($duplicates) > 0) {
            throw new DuplicateEntityException(sprintf(__("You already own a Tag called '%s'. Please choose another name."), $this->tag));
        }
    }

/**
     * Assign Layout
     * @param int $layoutId
     * @throws InvalidArgumentException
     */
    public function assignLayout($layoutId)
    {
        $this->load();

foreach ($this->layouts as $id => $value) {

if ($id == $layoutId) {
                $v = implode("", $value);
            }
        }

$this->validateTagOptions();

if (!array_key_exists($layoutId, $this->layouts)) {
            $this->layouts[$layoutId][] = $this->value;
        } elseif (array_key_exists($layoutId, $this->layouts) && $v != $this->value) {
            $this->layouts[$layoutId] = [$this->value];
        }
        else {
            $this->getLog()->debug('Assignment already exists with the same value, no need to update');
        }
    }

/**
     * Unassign Layout
     * @param int $layoutId
     */
    public function unassignLayout($layoutId)
    {
        $this->load();

if (array_key_exists($layoutId, $this->layouts)) {
            unset($this->layouts[$layoutId]);
        }
    }

/**
     * Assign Playlist
     * @param int $playlistId
     * @throws InvalidArgumentException
     */
    public function assignPlaylist($playlistId)
    {
        $this->load();

foreach ($this->playlists as $id => $value) {
            if ($id == $playlistId) {
                $v = implode("", $value);
            }
        }

$this->validateTagOptions();

if (!array_key_exists($playlistId, $this->playlists)) {
            $this->playlists[$playlistId][] = $this->value;
        } elseif (array_key_exists($playlistId, $this->playlists) && $v != $this->value) {
            $this->playlists[$playlistId] = [$this->value];
        }
        else {
            $this->getLog()->debug('Assignment already exists with the same value, no need to update');
        }
    }

/**
     * Unassign Playlist
     * @param int $playlistId
     */
    public function unassignPlaylist($playlistId)
    {
        $this->load();

if (array_key_exists($playlistId, $this->playlists)) {
            unset($this->playlists[$playlistId]);
        }
    }

/**
     * Assign Media
     * @param int $mediaId
     * @throws InvalidArgumentException
     */
    public function assignMedia($mediaId)
    {
        $this->load();

foreach ($this->medias as $id => $value) {
            if ($id == $mediaId) {
                $v = implode("", $value);
            }
        }

$this->validateTagOptions();

if (!array_key_exists($mediaId, $this->medias)) {
            $this->medias[$mediaId][] = $this->value;
        } elseif (array_key_exists($mediaId, $this->medias) && $v != $this->value) {
            $this->medias[$mediaId] = [$this->value];
        }
        else {
            $this->getLog()->debug('Assignment already exists with the same value, no need to update');
        }
    }

/**
     * Unassign Media
     * @param int $mediaId
     */
    public function unassignMedia($mediaId)
    {
        $this->load();

if (array_key_exists($mediaId, $this->medias)) {
            unset($this->medias[$mediaId]);
        }
    }

/**
     * Assign Campaign
     * @param int $campaignId
     * @throws InvalidArgumentException
     */
    public function assignCampaign($campaignId)
    {
        $this->load();

foreach ($this->campaigns as $id => $value) {
            if ($id == $campaignId) {
                $v = implode("", $value);
            }
        }

$this->validateTagOptions();

if (!array_key_exists($campaignId, $this->campaigns)) {
            $this->campaigns[$campaignId][] = $this->value;
        } elseif (array_key_exists($campaignId, $this->campaigns) && $v != $this->value) {
            $this->campaigns[$campaignId] = [$this->value];
        }
        else {
            $this->getLog()->debug('Assignment already exists with the same value, no need to update');
        }
    }

/**
     * Unassign Campaign
     * @param int $campaignId
     */
    public function unassignCampaign($campaignId)
    {
        $this->load();

if (array_key_exists($campaignId, $this->campaigns)) {
            unset($this->campaigns[$campaignId]);
        }
    }

/**
     * Assign DisplayGroup
     * @param int $displayGroupId
     * @throws InvalidArgumentException
     */
    public function assignDisplayGroup($displayGroupId)
    {
        $this->load();

foreach ($this->displayGroups as $id => $value) {
            if ($id == $displayGroupId) {
                $v = implode("", $value);
            }
        }

$this->validateTagOptions();

if (!array_key_exists($displayGroupId, $this->displayGroups)) {
            $this->displayGroups[$displayGroupId][] = $this->value;
        } elseif (array_key_exists($displayGroupId, $this->displayGroups) && $v != $this->value) {
            $this->displayGroups[$displayGroupId] = [$this->value];
        }
        else {
            $this->getLog()->debug('Assignment already exists with the same value, no need to update');
        }
    }

/**
     * Unassign DisplayGroup
     * @param int $displayGroupId
     */
    public function unassignDisplayGroup($displayGroupId)
    {
        $this->load();

if (array_key_exists($displayGroupId, $this->displayGroups)) {
            unset($this->displayGroups[$displayGroupId]);
        }
    }

/**
     * Load
     */
    public function load()
    {
        if ($this->tagId == null || $this->loaded)
            return;

$this->layouts = [];
        foreach ($this->getStore()->select('SELECT layoutId, value FROM `lktaglayout` WHERE tagId = :tagId', ['tagId' => $this->tagId]) as $row) {
            $this->layouts[$row['layoutId']][] = $row['value'];
        }

$this->campaigns = [];
        foreach ($this->getStore()->select('SELECT campaignId, value FROM `lktagcampaign` WHERE tagId = :tagId', ['tagId' => $this->tagId]) as $row) {
            $this->campaigns[$row['campaignId']][] = $row['value'];
        }

$this->playlists = [];
        foreach ($this->getStore()->select('SELECT playlistId, value FROM `lktagplaylist` WHERE tagId = :tagId', ['tagId' => $this->tagId]) as $row) {
            $this->playlists[$row['playlistId']][] = $row['value'];
        }

$this->medias = [];
        foreach ($this->getStore()->select('SELECT mediaId, value FROM `lktagmedia` WHERE tagId = :tagId', ['tagId' => $this->tagId]) as $row) {
            $this->medias[$row['mediaId']][] = $row['value'];
        }

$this->displayGroups = [];
        foreach ($this->getStore()->select('SELECT displayGroupId, value FROM `lktagdisplaygroup` WHERE tagId = :tagId', ['tagId' => $this->tagId]) as $row) {
            $this->displayGroups[$row['displayGroupId']][] = $row['value'];
        }
    
        // Set the originals
        $this->originalLayouts = $this->layouts;
        $this->originalPlaylists = $this->playlists;
        $this->originalCampaigns = $this->campaigns;
        $this->originalMedias = $this->medias;
        $this->originalDisplayGroups = $this->displayGroups;

$this->loaded = true;
    }

/**
     * Save
     * @param array $options
     * @throws DuplicateEntityException
     * @throws InvalidArgumentException
     */
    public function save($options = [])
    {
        // Default options
        $options = array_merge([
            'validate' => false
        ], $options);

if ($options['validate']) {
            $this->validate();
        }

// If the tag doesn't exist already - save it
        if ($this->tagId == null || $this->tagId == 0) {
            $this->add();
        } else {
            $this->update();
        }

// Manage the links to layouts and media
        $this->linkLayouts();
        $this->linkPlaylists();
        $this->linkCampaigns();
        $this->linkMedia();
        $this->linkDisplayGroups();
        $this->removeAssignments();

$this->getLog()->debug('Saving Tag: %s, %d', $this->tag, $this->tagId);
    }

/**
     * Remove Assignments
     */
    public function removeAssignments()
    {
        $this->unlinkLayouts();
        $this->unlinkPlaylists();
        $this->unlinkCampaigns();
        $this->unlinkMedia();
        $this->unlinkDisplayGroups();
    }

/**
     * Add a tag
     * @throws \PDOException
     */
    private function add()
    {
        $this->tagId = $this->getStore()->insert('INSERT INTO `tag` (tag, isRequired, options) VALUES (:tag, :isRequired, :options) ON DUPLICATE KEY UPDATE tag = tag', [
            'tag' => $this->tag,
            'isRequired' => $this->isRequired,
            'options' => ($this->options == null) ? null : $this->options
        ]);
    }

/**
     * Update a Tag
     * @throws \PDOException
     */
    private function update()
    {
        $this->getStore()->update('UPDATE `tag` SET tag = :tag, isRequired = :isRequired, options = :options WHERE tagId = :tagId', [
            'tagId' => $this->tagId,
            'tag' => $this->tag,
            'isRequired' => $this->isRequired,
            'options' => ($this->options == null) ? null : $this->options
        ]);
    }

/**
     * Delete Tag
     */
    public function delete()
    {
        $this->load();

//remove assignments
        $this->removeAssignments();
        // Delete the Tag record
        $this->getStore()->update('DELETE FROM `tag` WHERE tagId = :tagId', ['tagId' => $this->tagId]);
    }

/**
     * Link all assigned layouts
     */
    private function linkLayouts()
    {
        $layoutsToLink = $this->compareMultidimensionalArrays($this->layouts, $this->originalLayouts);

$this->getLog()->debug('Linking %d layouts to Tag %s', count($layoutsToLink), $this->tag);

// Layouts that are in layoutIds but not in originalLayoutIds
        foreach ($layoutsToLink as $layoutId => $value) {

$this->getStore()->update('INSERT INTO `lktaglayout` (tagId, layoutId, value) VALUES (:tagId, :layoutId, :value) ON DUPLICATE KEY UPDATE layoutId = layoutId, value = :value',
                [
                    'tagId' => $this->tagId,
                    'layoutId' => $layoutId,
                    'value' => $this->value
                ]);
        }
    }

/**
     * Unlink all assigned Layouts
     */
    private function unlinkLayouts()
    {
        // Layouts that are in the originalLayoutIds but not in the current layoutIds
        $layoutsToUnlink = $this->compareMultidimensionalArrays($this->originalLayouts, $this->layouts, false);

if (count($layoutsToUnlink) <= 0) {
            return;
        }

$this->getLog()->debug('Unlinking %d layouts from Tag %s', count($layoutsToUnlink), $this->tag);

// Unlink any layouts that are NOT in the collection
        $params = ['tagId' => $this->tagId];

$sql = 'DELETE FROM `lktaglayout` WHERE tagId = :tagId AND layoutId IN (0';

$i = 0;
        foreach ($layoutsToUnlink as $layoutId => $value) {
            $i++;
            $sql .= ',:layoutId' . $i;
            $params['layoutId' . $i] = $layoutId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Link all assigned playlists
     */
    private function linkPlaylists()
    {
        $playlistsToLink =  $this->compareMultidimensionalArrays($this->playlists, $this->originalPlaylists);

$this->getLog()->debug('Linking %d playlists to Tag %s', count($playlistsToLink), $this->tag);

// Playlists that are in playlistIds but not in originalLayoutIds
        foreach ($playlistsToLink as $playlistId => $value) {
            $this->getStore()->update('INSERT INTO `lktagplaylist` (tagId, playlistId, value) VALUES (:tagId, :playlistId, :value) ON DUPLICATE KEY UPDATE playlistId = playlistId, value = :value', [
                'tagId' => $this->tagId,
                'playlistId' => $playlistId,
                'value' => $this->value
            ]);
        }
    }

/**
     * Unlink all assigned Playlists
     */
    private function unlinkPlaylists()
    {
        // Playlists that are in the originalLayoutIds but not in the current playlistIds
        $playlistsToUnlink = $this->compareMultidimensionalArrays($this->originalPlaylists, $this->playlists, false);

$this->getLog()->debug('Unlinking %d playlists from Tag %s', count($playlistsToUnlink), $this->tag);

if (count($playlistsToUnlink) <= 0)
            return;

// Unlink any playlists that are NOT in the collection
        $params = ['tagId' => $this->tagId];

$sql = 'DELETE FROM `lktagplaylist` WHERE tagId = :tagId AND playlistId IN (0';

$i = 0;
        foreach ($playlistsToUnlink as $playlistId => $value) {
            $i++;
            $sql .= ',:playlistId' . $i;
            $params['playlistId' . $i] = $playlistId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }
    
    
    /**
     * Link all assigned campaigns
     */
    private function linkCampaigns()
    {
        $campaignsToLink =$this->compareMultidimensionalArrays($this->campaigns, $this->originalCampaigns);

$this->getLog()->debug('Linking %d campaigns to Tag %s', count($campaignsToLink), $this->tag);

// Campaigns that are in campaignIds but not in originalCampaignIds
        foreach ($campaignsToLink as $campaignId => $value) {
            $this->getStore()->update('INSERT INTO `lktagcampaign` (tagId, CampaignId, value) VALUES (:tagId, :CampaignId, :value) ON DUPLICATE KEY UPDATE campaignId = campaignId, value = :value', [
                'tagId' => $this->tagId,
                'CampaignId' => $campaignId,
                'value' => $this->value
            ]);
        }
    }

/**
     * Unlink all assigned campaigns
     */
    private function unlinkCampaigns()
    {
        // Campaigns that are in the originalCampaignIds but not in the current campaignIds
        $campaignsToUnlink = $this->compareMultidimensionalArrays($this->originalCampaigns, $this->campaigns, false);

$this->getLog()->debug('Unlinking %d campaigns from Tag %s', count($campaignsToUnlink), $this->tag);

if (count($campaignsToUnlink) <= 0)
            return;

// Unlink any campaigns that are NOT in the collection
        $params = ['tagId' => $this->tagId];

$sql = 'DELETE FROM `lktagcampaign` WHERE tagId = :tagId AND CampaignId IN (0';

$i = 0;
        foreach ($campaignsToUnlink as $campaignId => $value) {
            $i++;
            $sql .= ',:CampaignId' . $i;
            $params['CampaignId' . $i] = $campaignId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Link all assigned media
     */
    private function linkMedia()
    {
        $mediaToLink = $this->compareMultidimensionalArrays($this->medias, $this->originalMedias);

$this->getLog()->debug('Linking %d media to Tag %s', count($mediaToLink), $this->tag);

foreach ($mediaToLink as $mediaId => $value) {
            $this->getStore()->update('INSERT INTO `lktagmedia` (tagId, mediaId, value) VALUES (:tagId, :mediaId, :value) ON DUPLICATE KEY UPDATE mediaId = mediaId, value = :value', [
                'tagId' => $this->tagId,
                'mediaId' => $mediaId,
                'value' => $this->value
            ]);
        }
    }

/**
     * Unlink all assigned media
     */
    private function unlinkMedia()
    {
        $mediaToUnlink = $this->compareMultidimensionalArrays($this->originalMedias, $this->medias, false);

$this->getLog()->debug('Unlinking %d media from Tag %s', count($mediaToUnlink), $this->tag);

// Unlink any layouts that are NOT in the collection
        if (count($mediaToUnlink) <= 0)
            return;

$params = ['tagId' => $this->tagId];

$sql = 'DELETE FROM `lktagmedia` WHERE tagId = :tagId AND mediaId IN (0';

$i = 0;
        foreach ($mediaToUnlink as $mediaId => $value) {
            $i++;
            $sql .= ',:mediaId' . $i;
            $params['mediaId' . $i] = $mediaId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Link all assigned displayGroups
     */
    private function linkDisplayGroups()
    {
        $displayGroupsToLink = $this->compareMultidimensionalArrays($this->displayGroups, $this->originalDisplayGroups);

$this->getLog()->debug('Linking ' . count($displayGroupsToLink) . ' displayGroups to Tag ' . $this->tag);

// DisplayGroups that are in $this->displayGroupIds but not in $this->originalDisplayGroupIds
        foreach ($displayGroupsToLink as $displayGroupId => $value) {
            $this->getStore()->update('INSERT INTO `lktagdisplaygroup` (tagId, displayGroupId, value) VALUES (:tagId, :displayGroupId, :value) ON DUPLICATE KEY UPDATE displayGroupId = displayGroupId, value = :value', [
                'tagId' => $this->tagId,
                'displayGroupId' => $displayGroupId,
                'value' => $this->value
            ]);
        }
    }

/**
     * Unlink all assigned displayGroups
     */
    private function unlinkDisplayGroups()
    {
        // DisplayGroups that are in the $this->originalDisplayGroupIds but not in the current $this->displayGroupIds
        $displayGroupsToUnlink = $this->compareMultidimensionalArrays($this->originalDisplayGroups, $this->displayGroups, false);

$this->getLog()->debug('Unlinking ' . count($displayGroupsToUnlink) . ' displayGroups from Tag ' . $this->tag);

if (count($displayGroupsToUnlink) <= 0)
            return;

// Unlink any displayGroups that are NOT in the collection
        $params = ['tagId' => $this->tagId];

$sql = 'DELETE FROM `lktagdisplaygroup` WHERE tagId = :tagId AND displayGroupId IN (0';

$i = 0;
        foreach ($displayGroupsToUnlink as $displayGroupId => $value) {
            $i++;
            $sql .= ',:displayGroupId' . $i;
            $params['displayGroupId' . $i] = $displayGroupId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Is this tag a system tag?
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function isSystemTag()
    {
        $tag = $this->tagFactory->getById($this->tagId);

return $tag->isSystem === 1;
    }

/**
     * @throws InvalidArgumentException
     */
    public function validateTagOptions()
    {
        if (isset($this->options)) {
            $tagOptionsString = implode(',', json_decode($this->options));
            $tagOptionsArray = explode(',', $tagOptionsString);

if (isset($this->value) && !in_array($this->value, $tagOptionsArray)) {
                throw new InvalidArgumentException(sprintf(__('Provided tag value %s, not found in tag %s options',
                    $this->value, $this->tag)), 'tags');
            }

if (!isset($this->value) && $this->isRequired == 1) {
                throw new InvalidArgumentException(sprintf(__('Provided Tag %s, requires a value', $this->tag)),
                    'tags');
            }
        }
    }

/**
     * Removes Tag value from lktagtables
     *
     * @param array $values An Array of values that should be removed from assignment
     */
    public function updateTagValues($values)
    {
        $this->getLog()->debug('Tag options were changed, the following values need to be removed ' . json_encode($values));

foreach ($values as $value) {
            $this->getLog()->debug('removing following value from lktag tables ' . $value);

$this->getStore()->update('UPDATE `lktagcampaign` SET `value` = null WHERE tagId = :tagId AND value = :value',
                [
                    'value' => $value,
                    'tagId' => $this->tagId
                ]);

$this->getStore()->update('UPDATE `lktagdisplaygroup` SET `value` = null WHERE tagId = :tagId AND value = :value',
                [
                    'value' => $value,
                    'tagId' => $this->tagId
                ]);

$this->getStore()->update('UPDATE `lktaglayout` SET `value` = null WHERE tagId = :tagId AND value = :value',
                [
                    'value' => $value,
                    'tagId' => $this->tagId
                ]);

$this->getStore()->update('UPDATE `lktagmedia` SET `value` = null WHERE tagId = :tagId AND value = :value',
                [
                    'value' => $value,
                    'tagId' => $this->tagId
                ]);

$this->getStore()->update('UPDATE `lktagplaylist` SET `value` = null WHERE tagId = :tagId AND value = :value',
                [
                    'value' => $value,
                    'tagId' => $this->tagId
                ]);

}
    }
}PK�������qY�m��N��N����Task.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (Task.php)
 */

namespace Xibo\Entity;
use Cron\CronExpression;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Task
 * @package Xibo\XTR
 */
class Task implements \JsonSerializable
{
    use EntityTrait;

public static $STATUS_RUNNING = 1;
    public static $STATUS_IDLE = 2;
    public static $STATUS_ERROR = 3;
    public static $STATUS_SUCCESS = 4;
    public static $STATUS_TIMEOUT = 5;

public $taskId;
    public $name;
    public $configFile;
    public $class;
    public $status;
    public $pid = 0;
    public $options = [];
    public $schedule;
    public $lastRunDt = 0;
    public $lastRunStartDt;
    public $lastRunMessage;
    public $lastRunStatus;
    public $lastRunDuration = 0;
    public $lastRunExitCode = 0;
    public $isActive;
    public $runNow;

/**
     * Command constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     */
    public function __construct($store, $log)
    {
        $this->setCommonDependencies($store, $log);
    }

/**
     * @return \DateTime|string
     */
    public function nextRunDate()
    {
        try {
            $cron = CronExpression::factory($this->schedule);

if ($this->lastRunDt == 0)
                return (new \DateTime())->format('U');

return $cron->getNextRunDate(\DateTime::createFromFormat('U', $this->lastRunDt))->format('U');
        } catch (\RuntimeException $e) {
            $this->getLog()->error('Invalid CRON expression for TaskId ' . $this->taskId);

$this->status = self::$STATUS_ERROR;
            return (new \DateTime())->add(new \DateInterval('P1Y'))->format('U');
        }
    }

/**
     * Set class and options
     * @throws NotFoundException
     */
    public function setClassAndOptions()
    {
        if ($this->configFile == null)
            throw new NotFoundException(__('No config file recorded for task. Please recreate.'));

// Get the class and default set of options from the config file.
        if (!file_exists(PROJECT_ROOT . $this->configFile))
            throw new NotFoundException(__('Config file not found for Task'));

$config = json_decode(file_get_contents(PROJECT_ROOT . $this->configFile), true);
        $this->class = $config['class'];
        $this->options = array_merge($config['options'], $this->options);
    }

/**
     * Validate
     * @throws InvalidArgumentException
     */
    private function validate()
    {
        // Test the CRON expression
        if (empty($this->schedule))
            throw new InvalidArgumentException(__('Please enter a CRON expression in the Schedule'), 'schedule');

try {
            $cron = CronExpression::factory($this->schedule);
            $cron->getNextRunDate();
        } catch (\RuntimeException $e) {
            throw new InvalidArgumentException(__('Invalid CRON expression in the Schedule'), 'schedule');
        }
    }

/**
     * Save
     * @param $options
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'connection' => 'default',
            'reconnect' => false
        ], $options);

if ($options['validate'])
            $this->validate();

if ($this->taskId == null)
            $this->add();
        else {
            // If we've transitioned from active to inactive, then reset the task status
            if ($this->getOriginalValue('isActive') != $this->isActive)
                $this->status = Task::$STATUS_IDLE;

$this->edit($options);
        }
    }

/**
     * Delete
     */
    public function delete()
    {
        $this->getStore()->update('DELETE FROM `task` WHERE `taskId` = :taskId', ['taskId' => $this->taskId]);
    }

private function add()
    {
        $this->taskId = $this->getStore()->insert('
            INSERT INTO `task` (`name`, `status`, `configFile`, `class`, `pid`, `options`, `schedule`, 
              `lastRunDt`, `lastRunMessage`, `lastRunStatus`, `lastRunDuration`, `lastRunExitCode`,
              `isActive`, `runNow`) VALUES
             (:name, :status, :configFile, :class, :pid, :options, :schedule, 
              :lastRunDt, :lastRunMessage, :lastRunStatus, :lastRunDuration, :lastRunExitCode,
              :isActive, :runNow)
        ', [
            'name' => $this->name,
            'status' => $this->status,
            'pid' => $this->pid,
            'configFile' => $this->configFile,
            'class' => $this->class,
            'options' => json_encode($this->options),
            'schedule' => $this->schedule,
            'lastRunDt' => $this->lastRunDt,
            'lastRunMessage' => $this->lastRunMessage,
            'lastRunStatus' => $this->lastRunStatus,
            'lastRunDuration' => $this->lastRunDuration,
            'lastRunExitCode' => $this->lastRunExitCode,
            'isActive' => $this->isActive,
            'runNow' => $this->runNow
        ]);
    }

/**
     * @param array $options
     */
    private function edit($options)
    {
        $this->getStore()->update('
            UPDATE `task` SET 
              `name` = :name, 
              `status` = :status, 
              `pid` = :pid,
              `configFile` = :configFile,
              `class` = :class,
              `options` = :options, 
              `schedule` = :schedule, 
              `lastRunDt` = :lastRunDt, 
              `lastRunMessage` = :lastRunMessage,
              `lastRunStatus` = :lastRunStatus,
              `lastRunDuration` = :lastRunDuration,
              `lastRunExitCode` = :lastRunExitCode,
              `isActive` = :isActive,
              `runNow` = :runNow
             WHERE `taskId` = :taskId
        ', [
            'taskId' => $this->taskId,
            'name' => $this->name,
            'status' => $this->status,
            'pid' => $this->pid,
            'configFile' => $this->configFile,
            'class' => $this->class,
            'options' => json_encode($this->options),
            'schedule' => $this->schedule,
            'lastRunDt' => $this->lastRunDt,
            'lastRunMessage' => $this->lastRunMessage,
            'lastRunStatus' => $this->lastRunStatus,
            'lastRunDuration' => $this->lastRunDuration,
            'lastRunExitCode' => $this->lastRunExitCode,
            'isActive' => $this->isActive,
            'runNow' => $this->runNow
        ], $options['connection'], $options['reconnect']);
    }
}PK�������qY��`��	���	����UserOption.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class UserOption
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class UserOption implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The userId that this Option applies to")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="The option name")
     * @var string
     */
    public $option;

/**
     * @SWG\Property(description="The option value")
     * @var string
     */
    public $value;

/**
     * @inheritdoc
     */
    public function __toString()
    {
        return $this->userId . '-' . $this->option . '-' . md5($this->value);
    }

public function save()
    {
        if (!$this->hasPropertyChanged('value')) {
            return;
        }

$this->getStore()->insert('INSERT INTO `useroption` (`userId`, `option`, `value`) VALUES (:userId, :option, :value) ON DUPLICATE KEY UPDATE `value` = :value2', [
            'userId' => $this->userId,
            'option' => $this->option,
            'value' => $this->value,
            'value2' => $this->value,
        ]);
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM `useroption` WHERE `userId` = :userId AND `option` = :option', [
            'userId' => $this->userId,
            'option' => $this->option
        ]);
    }
}PK�������qYuW!��!����Command.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Command.php)
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Factory\DisplayProfileFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Command
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Command implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="Command Id"
     * )
     * @var int
     */
    public $commandId;

/**
     * @SWG\Property(
     *  description="Command Name"
     * )
     * @var string
     */
    public $command;

/**
     * @SWG\Property(
     *  description="Unique Code"
     * )
     * @var string
     */
    public $code;

/**
     * @SWG\Property(
     *  description="Description"
     * )
     * @var string
     */
    public $description;

/**
     * @SWG\Property(
     *  description="User Id"
     * )
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(
     *  description="Command String - when child of a Display Profile"
     * )
     * @var string
     */
    public $commandString;

/**
     * @SWG\Property(
     *  description="Validation String - when child of a Display Profile"
     * )
     * @var string
     */
    public $validationString;

/**
     * @SWG\Property(description="A comma separated list of groups/users with permissions to this Command")
     * @var string
     */
    public $groupsWithPermissions;

/**
     * Display Profiles using this command
     * @var array[DisplayProfile]
     */
    private $displayProfiles = [];

/**
     * @var DisplayProfileFactory
     */
    private $displayProfileFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * Command constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     */
    public function __construct($store, $log, $permissionFactory)
    {
        $this->setCommonDependencies($store, $log);
        $this->permissionFactory = $permissionFactory;
    }

/**
     * @param DisplayProfileFactory $displayProfileFactory
     */
    public function setChildObjectDependencies($displayProfileFactory)
    {
        $this->displayProfileFactory = $displayProfileFactory;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->commandId;
    }

/**
     * Get OwnerId
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Validate
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->length(1, 254)->validate($this->command))
            throw new InvalidArgumentException(__('Please enter a command name between 1 and 254 characters'), 'command');

if (!v::alpha()->NoWhitespace()->notEmpty()->length(1, 50)->validate($this->code))
            throw new InvalidArgumentException(__('Please enter a code between 1 and 50 characters containing only alpha characters and no spaces'), 'code');

if (!v::stringType()->notEmpty()->length(1, 1000)->validate($this->description))
            throw new InvalidArgumentException(__('Please enter a description between 1 and 1000 characters'), 'description');
    }

/**
     * Load
     * @throws NotFoundException
     */
    public function load()
    {
        if ($this->loaded || $this->commandId == null)
            return;

$this->displayProfiles = $this->displayProfileFactory->getByCommandId($this->commandId);
    }

/**
     * Save
     * @param array $options
     *
     * @throws InvalidArgumentException
     */
    public function save($options = [])
    {
        $options = array_merge($options, ['validate' => true]);

if ($options['validate'])
            $this->validate();

if ($this->commandId == null)
            $this->add();
        else
            $this->edit();
    }

/**
     * Delete
     */
    public function delete()
    {
        if (!$this->loaded)
            $this->load();

// Remove from any display profiles
        foreach ($this->displayProfiles as $profile) {
            /* @var \Xibo\Entity\DisplayProfile $profile */
            $profile->unassignCommand($this);
            $profile->save(['validate' => false]);
        }

$this->getStore()->update('DELETE FROM `command` WHERE `commandId` = :commandId', ['commandId' => $this->commandId]);
    }

private function add()
    {
        $this->commandId = $this->getStore()->insert('INSERT INTO `command` (`command`, `code`, `description`, `userId`) VALUES (:command, :code, :description, :userId)', [
            'command' => $this->command,
            'code' => $this->code,
            'description' => $this->description,
            'userId' => $this->userId
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
            UPDATE `command` SET
              `command` = :command,
              `code` = :code,
              `description` = :description,
              `userId` = :userId
             WHERE `commandId` = :commandId
        ', [
            'command' => $this->command,
            'code' => $this->code,
            'description' => $this->description,
            'userId' => $this->userId,
            'commandId' => $this->commandId
        ]);
    }
}PK�������qY�;{�M��M����LogEntry.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Log.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class LogEntry
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class LogEntry
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Log ID")
     * @var int
     */
    public $logId;

/**
     * @SWG\Property(description="A unique run number for a set of Log Messages.")
     * @var string
     */
    public $runNo;

/**
     * @SWG\Property(description="A timestamp representing the CMS date this log message occured")
     * @var int
     */
    public $logDate;

/**
     * @SWG\Property(description="The Channel that generated this message. WEB/API/MAINT/TEST")
     * @var string
     */
    public $channel;

/**
     * @SWG\Property(description="The requested route")
     * @var string
     */
    public $page;

/**
     * @SWG\Property(description="The request method, GET/POST/PUT/DELETE")
     * @var string
     */
    public $function;

/**
     * @SWG\Property(description="The log message")
     * @var string
     */
    public $message;

/**
     * @SWG\Property(description="The display ID this message relates to or NULL for CMS")
     * @var int
     */
    public $displayId;

/**
     * @SWG\Property(description="The Log Level")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="The display this message relates to or CMS for CMS.")
     * @var string
     */
    public $display;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     */
    public function __construct($store, $log)
    {
        $this->setCommonDependencies($store, $log);
    }
}PK�������qYi{ᷳj���j����DisplayProfile.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Xibo\Event\DisplayProfileLoadedEvent;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Factory\CommandFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DisplayProfile
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DisplayProfile implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Display Profile")
     * @var int
     */
    public $displayProfileId;

/**
     * @SWG\Property(description="The name of this Display Profile")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="The player type that this Display Profile is for")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="The configuration options for this Profile")
     * @var string[]
     */
    public $config;

/**
     * @SWG\Property(description="A flag indicating if this profile should be used as the Default for the client type")
     * @var int
     */
    public $isDefault;

/**
     * @SWG\Property(description="The userId of the User that owns this profile")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="The default configuration options for this Profile")
     * @var string[]
     */
    public $configDefault;

/**
     * Commands associated with this profile.
     * @var Command[]
     */
    public $commands = [];

/** @var  string the client type */
    private $clientType;

/** @var array Combined configuration */
    private $configCombined = [];

/**
     * @var ConfigServiceInterface
     */
    private $configService;

/** @var EventDispatcherInterface  */
    private $dispatcher;

/**
     * @var CommandFactory
     */
    private $commandFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param EventDispatcherInterface $dispatcher
     * @param CommandFactory $commandFactory
     */
    public function __construct($store, $log, $config, $dispatcher, $commandFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->configService = $config;
        $this->dispatcher = $dispatcher;
        $this->commandFactory = $commandFactory;
    }

public function __clone()
    {
        $this->displayProfileId = null;
        $this->isDefault = 0;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->displayProfileId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Get Setting
     * @param $setting
     * @param null $default
     * @param bool $fromDefault
     * @return mixed
     */
    public function getSetting($setting, $default = null, $fromDefault = false)
    {
        $this->load();

$configs = ($fromDefault) ? $this->configDefault : $this->getProfileConfig();

foreach ($configs as $config) {
            if ($config['name'] == $setting || $config['name'] == ucfirst($setting)) {
                $default = array_key_exists('value', $config) ? $config['value'] : ((array_key_exists('default', $config)) ? $config['default'] : $default);
                break;
            }
        }

return $default;
    }

/**
     * Set setting
     * @param $setting
     * @param $value
     * @param boolean $ownConfig if provided will set the values on this object and not on the member config object
     * @param array|null $config
     * @return $this
     */
    public function setSetting($setting, $value, $ownConfig = true, &$config = null)
    {
        $this->load();

$found = false;

// Get the setting from default
        // Which object do we operate on.
        if ($ownConfig) {
            $config = $this->config;
            $default = $this->getSetting($setting, null, true);
        } else {
            // we are editing Display object, as such we want the $default to come from display profile assigned to our display
            $default = $this->getSetting($setting, null, false);
        }

// Check to see if we have this setting already
        for ($i = 0; $i < count($config); $i++) {
            if ($config[$i]['name'] == $setting || $config[$i]['name'] == ucfirst($setting)) {
                // We found the setting - is the value different to the default?
                if ($value !== $default) {
                    $config[$i]['value'] = $value;
                    $config[$i]['name'] = lcfirst($setting);
                } else {
                    // the value is the same as the default - unset it
                    $this->getLog()->debug('Setting [' . $setting . '] identical to the default, unsetting.');
                    unset($config[$i]);
                    $config = array_values($config);
                }
                $found = true;
                break;
            }
        }

if (!$found && $value !== $default) {
            $this->getLog()->debug('Setting [' . $setting . '] not yet in the profile config, and different to the default. ' . var_export($value, true) . ' --- ' . var_export($default, true));
            // The config option isn't in our array yet, so add it
            $config[] = [
                'name' => lcfirst($setting),
                'value' => $value
            ];
        }

if ($ownConfig) {
            // Reset our object
            $this->config = $config;

// Reload our combined array
            $this->configCombined = $this->mergeConfigs($this->configDefault, $this->config);
        }

return $this;
    }

/**
     * Merge two configs
     * @param $default
     * @param $override
     * @return array
     */
    private function mergeConfigs($default, $override)
    {
        foreach ($default as &$defaultItem) {
            for ($i = 0; $i < count($override); $i++) {
                if ($defaultItem['name'] == $override[$i]['name']) {
                    // merge
                    $defaultItem = array_merge($defaultItem, $override[$i]);
                    break;
                }
            }
        }

// Merge the remainder
        return $default;
    }

/**
     * @param $clientType
     */
    public function setClientType($clientType)
    {
        $this->clientType = $clientType;
    }

/**
     * Get the client type
     * @return string
     */
    public function getClientType()
    {
        return (empty($this->clientType)) ? $this->type : $this->clientType;
    }

/**
     * Assign Command
     * @param Command $command
     */
    public function assignCommand($command)
    {
        $this->load();

$assigned = false;

foreach ($this->commands as $alreadyAssigned) {
            /* @var Command $alreadyAssigned */
            if ($alreadyAssigned->getId() == $command->getId()) {
                $alreadyAssigned->commandString = $command->commandString;
                $alreadyAssigned->validationString = $command->validationString;
                $assigned = true;
                break;
            }
        }

if (!$assigned)
            $this->commands[] = $command;
    }

/**
     * Unassign Command
     * @param Command $command
     */
    public function unassignCommand($command)
    {
        $this->load();

$this->commands = array_udiff($this->commands, [$command], function ($a, $b) {
           /**
            * @var Command $a
            * @var Command $b
            */
            return $a->getId() - $b->getId();
        });
    }

/**
     * Load
     * @param array $options
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadConfig' => true,
            'loadCommands' => true
        ], $options);

if ($this->loaded) {
            return;
        }

// Load in our default config from this class, based on the client type we are
        $this->configDefault = $this->loadForType();

$this->getLog()->debug('Config Default is: ' . json_encode($this->configDefault, JSON_PRETTY_PRINT));

// Get our combined config
        $this->configCombined = [];

if ($options['loadConfig']) {
            // Decode the config string (unless its already an array)
            if (!is_array($this->config)) {
                $this->config = json_decode($this->config, true);
            }
            $this->getLog()->debug('Config loaded: ' . json_encode($this->config, JSON_PRETTY_PRINT));

// We've loaded a profile
            // dispatch an event with a reference to this object, allowing subscribers to modify the config before we
            // continue further.
            $this->dispatcher->dispatch(DisplayProfileLoadedEvent::NAME, new DisplayProfileLoadedEvent($this));

// Populate our combined config accordingly
            $this->configCombined = $this->mergeConfigs($this->configDefault, $this->config);
        }

$this->getLog()->debug('Config Combined is: ' . json_encode($this->configCombined, JSON_PRETTY_PRINT));

// Load any commands
        if ($options['loadCommands']) {
            $this->commands = $this->commandFactory->getByDisplayProfileId($this->displayProfileId);
        }

// We are loaded
        $this->loaded = true;
    }

/**
     * Validate
     * @throws \Xibo\Exception\InvalidArgumentException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->name))
            throw new InvalidArgumentException(__('Missing name'), 'name');

if (!v::stringType()->notEmpty()->validate($this->type))
            throw new InvalidArgumentException(__('Missing type'), 'type');

for ($j = 0; $j < count($this->config); $j++) {
            if ($this->config[$j]['name'] == 'MaxConcurrentDownloads' && $this->config[$j]['value'] <= 0 && $this->type = 'windows') {
                throw new InvalidArgumentException(__('Concurrent downloads must be a positive number'), 'MaxConcurrentDownloads');
            }

if ($this->config[$j]['name'] == 'maxRegionCount' && !v::intType()->min(0)->validate($this->config[$j]['value'])) {
                throw new InvalidArgumentException(__('Maximum Region Count must be a positive number'), 'maxRegionCount');
            }
        }
        // Check there is only 1 default (including this one)
        $sql = '
          SELECT COUNT(*) AS cnt
            FROM `displayprofile`
           WHERE `type` = :type
            AND isdefault = 1
        ';

$params = ['type' => $this->type];

if ($this->displayProfileId != 0) {
            $sql .= ' AND displayprofileid <> :displayProfileId ';
            $params['displayProfileId'] = $this->displayProfileId;
        }

$count = $this->getStore()->select($sql, $params);

if ($count[0]['cnt'] + $this->isDefault > 1) {
            throw new InvalidArgumentException(__('Only 1 default per display type is allowed.'), 'isDefault');
        }
    }

/**
     * Save
     * @param bool $validate
     * @throws \Xibo\Exception\InvalidArgumentException
     */
    public function save($validate = true)
    {
        if ($validate)
            $this->validate();

if ($this->displayProfileId == null || $this->displayProfileId == 0)
            $this->add();
        else
            $this->edit();

$this->manageAssignments();
    }

/**
     * Delete
     * @throws InvalidArgumentException
     */
    public function delete()
    {
        $this->commands = [];
        $this->manageAssignments();

if ($this->getStore()->exists('SELECT displayId FROM display WHERE displayProfileId = :displayProfileId', ['displayProfileId' => $this->displayProfileId]) ) {
            throw new InvalidArgumentException(__('This Display Profile is currently assigned to one or more Displays'), 'displayProfileId');
        }

$this->getStore()->update('DELETE FROM `displayprofile` WHERE displayprofileid = :displayProfileId', ['displayProfileId' => $this->displayProfileId]);
    }

/**
     * Manage Assignments
     */
    private function manageAssignments()
    {
        $this->getLog()->debug('Managing Assignment for Display Profile: %d. %d commands.', $this->displayProfileId, count($this->commands));

// Link
        foreach ($this->commands as $command) {
            /* @var Command $command */
            $this->getStore()->update('
              INSERT INTO `lkcommanddisplayprofile` (`commandId`, `displayProfileId`, `commandString`, `validationString`) VALUES
                (:commandId, :displayProfileId, :commandString, :validationString) ON DUPLICATE KEY UPDATE commandString = :commandString2, validationString = :validationString2
            ', [
                'commandId' => $command->commandId,
                'displayProfileId' => $this->displayProfileId,
                'commandString' => $command->commandString,
                'validationString' => $command->validationString,
                'commandString2' => $command->commandString,
                'validationString2' => $command->validationString
            ]);
        }

// Unlink
        $params = ['displayProfileId' => $this->displayProfileId];

$sql = 'DELETE FROM `lkcommanddisplayprofile` WHERE `displayProfileId` = :displayProfileId AND `commandId` NOT IN (0';

$i = 0;
        foreach ($this->commands as $command) {
            /* @var Command $command */
            $i++;
            $sql .= ',:commandId' . $i;
            $params['commandId' . $i] = $command->commandId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

private function add()
    {
        $this->displayProfileId = $this->getStore()->insert('
            INSERT INTO `displayprofile` (`name`, type, config, isdefault, userid)
              VALUES (:name, :type, :config, :isDefault, :userId)
        ', [
            'name' => $this->name,
            'type' => $this->type,
            'config' => ($this->config == '') ? '[]' : json_encode($this->config),
            'isDefault' => $this->isDefault,
            'userId' => $this->userId
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
          UPDATE `displayprofile`
            SET `name` = :name, type = :type, config = :config, isdefault = :isDefault
           WHERE displayprofileid = :displayProfileId', [
            'name' => $this->name,
            'type' => $this->type,
            'config' => ($this->config == '') ? '[]' : json_encode($this->config),
            'isDefault' => $this->isDefault,
            'displayProfileId' => $this->displayProfileId
        ]);
    }

/**
     * @return array
     */
    public function getProfileConfig()
    {
        return $this->configCombined;
    }

/**
     * Load the config from the file
     */
    private function loadForType()
    {
        $config = array(
            'unknown' => [],
            'windows' => [
                ['name' => 'collectInterval', 'default' => 300, 'type' => 'int'],
                ['name' => 'downloadStartWindow', 'default' => '00:00', 'type' => 'string'],
                ['name' => 'downloadEndWindow', 'default' => '00:00', 'type' => 'string'],
                ['name' => 'dayPartId', 'default' => null],
                ['name' => 'xmrNetworkAddress', 'default' => null, 'type' => 'string'],
                ['name' => 'statsEnabled', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_STATS_DEFAULT', 0), 'type' => 'checkbox'],
                ['name' => 'aggregationLevel', 'default' => $this->configService->getSetting('DISPLAY_PROFILE_AGGREGATION_LEVEL_DEFAULT'), 'type' => 'string'],
                ['name' => 'powerpointEnabled', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'sizeX', 'default' => 0, 'type' => 'double'],
                ['name' => 'sizeY', 'default' => 0, 'type' => 'double'],
                ['name' => 'offsetX', 'default' => 0, 'type' => 'double'],
                ['name' => 'offsetY', 'default' => 0, 'type' => 'double'],
                ['name' => 'clientInfomationCtrlKey', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'clientInformationKeyCode', 'default' => 'I', 'type' => 'string'],
                ['name' => 'logLevel', 'default' => 'error', 'type' => 'string'],
                ['name' => 'logToDiskLocation', 'default' => null, 'type' => 'string'],
                ['name' => 'showInTaskbar', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'cursorStartPosition', 'default' => 'Unchanged', 'type' => 'string'],
                ['name' => 'doubleBuffering', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'emptyLayoutDuration', 'default' => 10, 'type' => 'int'],
                ['name' => 'enableMouse', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'enableShellCommands', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'expireModifiedLayouts', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'maxConcurrentDownloads', 'default' => 2, 'type' => 'int'],
                ['name' => 'shellCommandAllowList', 'default' => null, 'type' => 'string'],
                ['name' => 'sendCurrentLayoutAsStatusUpdate', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'screenShotRequestInterval', 'default' => 0, 'type' => 'int'],
                ['name' => 'screenShotSize', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_SCREENSHOT_SIZE_DEFAULT', 200), 'type' => 'int'],
                ['name' => 'maxLogFileUploads', 'default' => 3, 'type' => 'int'],
                ['name' => 'embeddedServerPort', 'default' => 9696, 'type' => 'int'],
                ['name' => 'preventSleep', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'forceHttps', 'default' => 1, 'type' => 'checkbox']
            ],
            'android' => [
                ['name' => 'emailAddress', 'default' => null],
                ['name' => 'settingsPassword', 'default' => null],
                ['name' => 'collectInterval', 'default' => 300],
                ['name' => 'downloadStartWindow', 'default' => '00:00'],
                ['name' => 'downloadEndWindow', 'default' => '00:00'],
                ['name' => 'xmrNetworkAddress', 'default' => null],
                ['name' => 'statsEnabled', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_STATS_DEFAULT', 0), 'type' => 'checkbox'],
                ['name' => 'aggregationLevel', 'default' => $this->configService->getSetting('DISPLAY_PROFILE_AGGREGATION_LEVEL_DEFAULT'), 'type' => 'string'],
                ['name' => 'orientation', 'default' => 0],
                ['name' => 'screenDimensions', 'default' => null],
                ['name' => 'blacklistVideo', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'storeHtmlOnInternal', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'useSurfaceVideoView', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'logLevel', 'default' => 'error'],
                ['name' => 'versionMediaId', 'default' => null],
                ['name' => 'startOnBoot', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'actionBarMode', 'default' => 1],
                ['name' => 'actionBarDisplayDuration', 'default' => 30],
                ['name' => 'actionBarIntent', 'default' => null],
                ['name' => 'autoRestart', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'startOnBootDelay', 'default' => 60],
                ['name' => 'sendCurrentLayoutAsStatusUpdate', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'screenShotRequestInterval', 'default' => 0],
                ['name' => 'expireModifiedLayouts', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'screenShotIntent', 'default' => null],
                ['name' => 'screenShotSize', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_SCREENSHOT_SIZE_DEFAULT', 200)],
                ['name' => 'updateStartWindow', 'default' => '00:00'],
                ['name' => 'updateEndWindow', 'default' => '00:00'],
                ['name' => 'dayPartId', 'default' => null],
                ['name' => 'webViewPluginState', 'default' => 'DEMAND'],
                ['name' => 'hardwareAccelerateWebViewMode', 'default' => '2'],
                ['name' => 'timeSyncFromCms', 'default' => 0],
                ['name' => 'webCacheEnabled', 'default' => 0],
                ['name' => 'serverPort', 'default' => 9696],
                ['name' => 'installWithLoadedLinkLibraries', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'forceHttps', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'useMultipleVideoDecoders', 'default' => 'default', 'type' => 'string'],
                ['name' => 'maxRegionCount', 'default' => 0]
            ],
            'linux' => [
                ['name' => 'collectInterval', 'default' => 300],
                ['name' => 'downloadStartWindow', 'default' => '00:00'],
                ['name' => 'downloadEndWindow', 'default' => '00:00'],
                ['name' => 'dayPartId', 'default' => null],
                ['name' => 'xmrNetworkAddress', 'default' => null],
                ['name' => 'statsEnabled', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_STATS_DEFAULT', 0), 'type' => 'checkbox'],
                ['name' => 'aggregationLevel', 'default' => $this->configService->getSetting('DISPLAY_PROFILE_AGGREGATION_LEVEL_DEFAULT'), 'type' => 'string'],
                ['name' => 'sizeX', 'default' => 0],
                ['name' => 'sizeY', 'default' => 0],
                ['name' => 'offsetX', 'default' => 0],
                ['name' => 'offsetY', 'default' => 0],
                ['name' => 'logLevel', 'default' => 'error'],
                ['name' => 'enableShellCommands', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'expireModifiedLayouts', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'maxConcurrentDownloads', 'default' => 2],
                ['name' => 'shellCommandAllowList', 'default' => null],
                ['name' => 'sendCurrentLayoutAsStatusUpdate', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'screenShotRequestInterval', 'default' => 0],
                ['name' => 'screenShotSize', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_SCREENSHOT_SIZE_DEFAULT', 200)],
                ['name' => 'maxLogFileUploads', 'default' => 3],
                ['name' => 'embeddedServerPort', 'default' => 9696],
                ['name' => 'preventSleep', 'default' => 1, 'type' => 'checkbox'],
                ['name' => 'forceHttps', 'default' => 1, 'type' => 'checkbox']
            ],
            'lg' => [
                ['name' => 'emailAddress', 'default' => null],
                ['name' => 'collectInterval', 'default' => 300],
                ['name' => 'downloadStartWindow', 'default' => '00:00'],
                ['name' => 'downloadEndWindow', 'default' => '00:00'],
                ['name' => 'dayPartId', 'default' => null],
                ['name' => 'xmrNetworkAddress', 'default' => null],
                ['name' => 'statsEnabled', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_STATS_DEFAULT', 0), 'type' => 'checkbox'],
                ['name' => 'aggregationLevel', 'default' => $this->configService->getSetting('DISPLAY_PROFILE_AGGREGATION_LEVEL_DEFAULT'), 'type' => 'string'],
                ['name' => 'orientation', 'default' => 0],
                ['name' => 'logLevel', 'default' => 'error'],
                ['name' => 'versionMediaId', 'default' => null],
                ['name' => 'actionBarMode', 'default' => 1],
                ['name' => 'actionBarDisplayDuration', 'default' => 30],
                ['name' => 'sendCurrentLayoutAsStatusUpdate', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'mediaInventoryTimer', 'default' => 0],
                ['name' => 'screenShotSize', 'default' => 1],
                ['name' => 'timers', 'default' => '{}'],
                ['name' => 'pictureOptions', 'default' => '{}'],
                ['name' => 'lockOptions', 'default' => '{}'],
                ['name' => 'forceHttps', 'default' => 1, 'type' => 'checkbox']
            ],
            'sssp' => [
                ['name' => 'emailAddress', 'default' => null],
                ['name' => 'collectInterval', 'default' => 300],
                ['name' => 'downloadStartWindow', 'default' => '00:00'],
                ['name' => 'downloadEndWindow', 'default' => '00:00'],
                ['name' => 'dayPartId', 'default' => null],
                ['name' => 'xmrNetworkAddress', 'default' => null],
                ['name' => 'statsEnabled', 'default' => (int)$this->configService->getSetting('DISPLAY_PROFILE_STATS_DEFAULT', 0), 'type' => 'checkbox'],
                ['name' => 'aggregationLevel', 'default' => $this->configService->getSetting('DISPLAY_PROFILE_AGGREGATION_LEVEL_DEFAULT'), 'type' => 'string'],
                ['name' => 'orientation', 'default' => 0],
                ['name' => 'logLevel', 'default' => 'error'],
                ['name' => 'versionMediaId', 'default' => null],
                ['name' => 'actionBarMode', 'default' => 1],
                ['name' => 'actionBarDisplayDuration', 'default' => 30],
                ['name' => 'sendCurrentLayoutAsStatusUpdate', 'default' => 0, 'type' => 'checkbox'],
                ['name' => 'mediaInventoryTimer', 'default' => 0],
                ['name' => 'screenShotSize', 'default' => 1],
                ['name' => 'timers', 'default' => '{}'],
                ['name' => 'pictureOptions', 'default' => '{}'],
                ['name' => 'lockOptions', 'default' => '{}'],
                ['name' => 'forceHttps', 'default' => 1, 'type' => 'checkbox']
            ]
        );

return $config[$this->getClientType()];
    }
}PK�������qY�Mc%������WidgetAudio.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (WidgetAudio.php)
 */

namespace Xibo\Entity;

use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class WidgetAudio
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class WidgetAudio implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The Widget Id")
     * @var int
     */
    public $widgetId;

/**
     * @SWG\Property(description="The Media Id")
     * @var int
     */
    public $mediaId;

/**
     * @SWG\Property(description="The percentage volume")
     * @var int
     */
    public $volume;

/**
     * @SWG\Property(description="Flag indicating whether to loop")
     * @var int
     */
    public $loop;

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->mediaId;
    }

/**
     * Save this widget audio
     */
    public function save()
    {
        $sql = '
          INSERT INTO `lkwidgetaudio` (widgetId, mediaId, `volume`, `loop`)
            VALUES (:widgetId, :mediaId, :volume, :loop)
          ON DUPLICATE KEY UPDATE volume = :volume, `loop` = :loop
        ';

$this->getStore()->insert($sql, array(
            'widgetId' => $this->widgetId,
            'mediaId' => $this->mediaId,
            'volume' => $this->volume,
            'loop' => $this->loop
        ));
    }

/**
     * Delete this widget audio
     */
    public function delete()
    {
        $this->getStore()->update('
            DELETE FROM `lkwidgetaudio`
              WHERE widgetId = :widgetId AND mediaId = :mediaId
        ', [
            'widgetId' => $this->widgetId,
            'mediaId' => $this->mediaId
        ]);
    }
}PK�������qYZ�օ-~��-~����DisplayGroup.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (DisplayGroup.php)
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Factory\TagFactory;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DisplayGroup
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DisplayGroup implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="The displayGroup Id"
     * )
     * @var int
     */
    public $displayGroupId;

/**
     * @SWG\Property(
     *  description="The displayGroup Name"
     * )
     * @var string
     */
    public $displayGroup;

/**
     * @SWG\Property(
     *  description="The displayGroup Description"
     * )
     * @var string
     */
    public $description;

/**
     * @SWG\Property(
     *  description="A flag indicating whether this displayGroup is a single display displayGroup",
     * )
     * @var int
     */
    public $isDisplaySpecific = 0;

/**
     * @SWG\Property(
     *  description="A flag indicating whether this displayGroup is dynamic",
     * )
     * @var int
     */
    public $isDynamic = 0;

/**
     * @SWG\Property(
     *  description="Criteria for this dynamic group. A comma separated set of regular expressions to apply",
     * )
     * @var string
     */
    public $dynamicCriteria;

/**
     * @SWG\Property(
     *  description="Criteria for this dynamic group. A comma separated set of tags to apply",
     * )
     * @var string
     */
    public $dynamicCriteriaTags;

/**
     * @SWG\Property(
     *  description="The UserId who owns this display group",
     * )
     * @var int
     */
    public $userId = 0;

/**
     * @SWG\Property(description="Tags associated with this DisplayGroup")
     * @var Tag[]
     */
    public $tags = [];
    public $tagValues;

/**
     * @SWG\Property(description="The display bandwidth limit")
     * @var int
     */
    public $bandwidthLimit;

/**
     * Minimum save options
     * @var array
     */
    public static $saveOptionsMinimum = [
        'validate' => false,
        'saveGroup' => true,
        'manageLinks' => false,
        'manageDisplayLinks' => false
    ];

// Child Items the Display Group is linked to
    private $displays = [];
    private $displayGroups = [];
    private $layouts = [];
    private $media = [];
    private $permissions = [];
    private $events = [];
    private $unassignTags = [];

// Track original assignments
    private $originalDisplayGroups = [];

/**
     * Is notify required during save?
     * @var bool
     */
    private $notifyRequired = false;

/**
     * Is collect required?
     * @var bool
     */
    private $collectRequired = true;

/**
     * @var bool Are we allowed to notify?
     */
    private $allowNotify = true;

/**
     * @var DisplayFactory
     */
    private $displayFactory;

/**
     * @var DisplayGroupFactory
     */
    private $displayGroupFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var ScheduleFactory
     */
    private $scheduleFactory;

/**
     * @var TagFactory
     */
    private $tagFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param DisplayGroupFactory $displayGroupFactory
     * @param PermissionFactory $permissionFactory
     * @param TagFactory $tagFactory
     */
    public function __construct($store, $log, $displayGroupFactory, $permissionFactory, $tagFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->displayGroupFactory = $displayGroupFactory;
        $this->permissionFactory = $permissionFactory;
        $this->tagFactory = $tagFactory;
    }

public function __clone()
    {
        $this->displayGroupId = null;
    }

/**
     * Set child object dependencies
     * @param DisplayFactory $displayFactory
     * @param LayoutFactory $layoutFactory
     * @param MediaFactory $mediaFactory
     * @param ScheduleFactory $scheduleFactory
     * @return $this
     */
    public function setChildObjectDependencies($displayFactory, $layoutFactory, $mediaFactory, $scheduleFactory)
    {
        $this->displayFactory = $displayFactory;
        $this->layoutFactory = $layoutFactory;
        $this->mediaFactory = $mediaFactory;
        $this->scheduleFactory = $scheduleFactory;
        return $this;
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->displayGroupId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Set the owner of this group
     * @param $userId
     */
    public function setOwner($userId)
    {
        $this->userId = $userId;
    }

/**
     * @return bool
     */
    public function canChangeOwner()
    {
        return $this->isDisplaySpecific == 0;
    }

/**
     * Set Collection Required
     *  If true will send a player action to collect immediately
     * @param bool|true $collectRequired
     */
    public function setCollectRequired($collectRequired = true)
    {
        $this->collectRequired = $collectRequired;
    }

/**
     * Set the Owner of this Group
     * @param Display $display
     */
    public function setDisplaySpecificDisplay($display)
    {
        $this->load();

$this->isDisplaySpecific = 1;
        $this->assignDisplay($display);
    }

/**
     * Set the Media Status to Incomplete
     * @param int[] $displayIds
     */
    public function notify($displayIds = [])
    {
        if ($this->allowNotify) {

$notify = $this->displayFactory->getDisplayNotifyService();

if ($this->collectRequired)
                $notify->collectNow();

if (count($displayIds) > 0) {
                foreach ($displayIds as $displayId) {
                    $notify->notifyByDisplayId($displayId);
                }
            } else {
                $notify->notifyByDisplayGroupId($this->displayGroupId);
            }
        }
    }

/**
     * Assign Display
     * @param Display $display
     */
    public function assignDisplay($display)
    {
        $this->load();

$found = false;
        foreach ($this->displays as $existingDisplay) {
            if ($existingDisplay->getId() === $display->getId()) {
                $found = true;
                break;
            }
        }

if (!$found)
            $this->displays[] = $display;
    }

/**
     * Unassign Display
     * @param Display $display
     */
    public function unassignDisplay($display)
    {
        $this->load();

// Changes made?
        $countBefore = count($this->displays);

$this->displays = array_udiff($this->displays, [$display], function($a, $b) {
            /**
             * @var Display $a
             * @var Display $b
             */
            return $a->getId() - $b->getId();
        });

// Notify if necessary
        if ($countBefore !== count($this->displays))
            $this->notifyRequired = true;
    }

/**
     * Assign DisplayGroup
     * @param DisplayGroup $displayGroup
     */
    public function assignDisplayGroup($displayGroup)
    {
        $this->load();

if (!in_array($displayGroup, $this->displayGroups))
            $this->displayGroups[] = $displayGroup;
    }

/**
     * Unassign DisplayGroup
     * @param DisplayGroup $displayGroup
     */
    public function unassignDisplayGroup($displayGroup)
    {
        $this->load();

// Changes made?
        $countBefore = count($this->displayGroups);

$this->displayGroups = array_udiff($this->displayGroups, [$displayGroup], function($a, $b) {
            /**
             * @var DisplayGroup $a
             * @var DisplayGroup $b
             */
            return $a->getId() - $b->getId();
        });

// Notify if necessary
        if ($countBefore !== count($this->displayGroups))
            $this->notifyRequired = true;
    }

/**
     * Assign Media
     * @param Media $media
     */
    public function assignMedia($media)
    {
        $this->load();

if (!in_array($media, $this->media)) {
            $this->media[] = $media;

// We should notify
            $this->notifyRequired = true;
        }
    }

/**
     * Unassign Media
     * @param Media $media
     */
    public function unassignMedia($media)
    {
        $this->load();

// Changes made?
        $countBefore = count($this->media);

$this->media = array_udiff($this->media, [$media], function($a, $b) {
            /**
             * @var Media $a
             * @var Media $b
             */
            return $a->getId() - $b->getId();
        });

// Notify if necessary
        if ($countBefore !== count($this->media))
            $this->notifyRequired = true;
    }

/**
     * Assign Layout
     * @param Layout $layout
     */
    public function assignLayout($layout)
    {
        $this->load();

if (!in_array($layout, $this->layouts)) {
            $this->layouts[] = $layout;

// We should notify
            $this->notifyRequired = true;
        }
    }

/**
     * Unassign Layout
     * @param Layout $layout
     */
    public function unassignLayout($layout)
    {
        $this->load();

// Changes made?
        $countBefore = count($this->layouts);

$this->layouts = array_udiff($this->layouts, [$layout], function($a, $b) {
            /**
             * @var Layout $a
             * @var Layout $b
             */
            return $a->getId() - $b->getId();
        });

// Notify if necessary
        if ($countBefore !== count($this->layouts))
            $this->notifyRequired = true;
    }

/**
     * Does the campaign have the provided tag?
     * @param $searchTag
     * @return bool
     */
    public function hasTag($searchTag)
    {
        $this->load();

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            if ($tag->tag == $searchTag)
                return true;
        }

return false;
    }

/**
     * Assign Tag
     * @param Tag $tag
     * @return $this
     * @throws NotFoundException
     */
    public function assignTag($tag)
    {
        $this->load();

if ($this->tags != [$tag]) {

if (!in_array($tag, $this->tags)) {
                $this->tags[] = $tag;
            }
        } else {
            $this->getLog()->debug('No Tags to assign');
        }

return $this;
    }

/**
     * Unassign tag
     * @param Tag $tag
     * @return $this
     * @throws NotFoundException
     */
    public function unassignTag($tag)
    {
        $this->load();
        $this->tags = array_udiff($this->tags, [$tag], function($a, $b) {
            /* @var Tag $a */
            /* @var Tag $b */
            return $a->tagId - $b->tagId;
        });

$this->unassignTags[] = $tag;

$this->getLog()->debug('Tags after removal %s', json_encode($this->tags));

return $this;
    }

/**
     * @param array[Tag] $tags
     */
    public function replaceTags($tags = [])
    {
        if (!is_array($this->tags) || count($this->tags) <= 0)
            $this->tags = $this->tagFactory->loadByDisplayGroupId($this->displayGroupId);

$this->getLog()->debug('Tags to be removed: %s', json_encode($this->unassignTags));

// Replace the arrays
            $this->tags = $tags;

$this->getLog()->debug('Tags remaining: %s', json_encode($this->tags));
        } else {
            $this->getLog()->debug('Tags were not changed');
        }
    }

/**
     * Load the contents for this display group
     * @param array $options
     * @throws NotFoundException
     */
    public function load($options = [])
    {
        $options = array_merge([
            'loadTags' => true
        ], $options);

if ($this->loaded || $this->displayGroupId == null || $this->displayGroupId == 0)
            return;

if ($this->permissionFactory == null || $this->displayFactory == null || $this->displayGroupFactory == null || $this->layoutFactory == null || $this->mediaFactory == null || $this->scheduleFactory == null)
            throw new \RuntimeException('Cannot load without first calling setChildObjectDependencies');

$this->permissions = $this->permissionFactory->getByObjectId(get_class($this), $this->displayGroupId);

$this->displays = $this->displayFactory->getByDisplayGroupId($this->displayGroupId);

$this->displayGroups = $this->displayGroupFactory->getByParentId($this->displayGroupId);

$this->layouts = $this->layoutFactory->getByDisplayGroupId($this->displayGroupId);

$this->media = $this->mediaFactory->getByDisplayGroupId($this->displayGroupId);

$this->events = $this->scheduleFactory->getByDisplayGroupId($this->displayGroupId);

// Load all tags
        if ($options['loadTags'])
            $this->tags = $this->tagFactory->loadByDisplayGroupId($this->displayGroupId);

// Set the originals
        $this->originalDisplayGroups = $this->displayGroups;

// We are loaded
        $this->loaded = true;
    }

/**
     * Validate this display
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->displayGroup))
            throw new InvalidArgumentException(__('Please enter a display group name'), 'displayGroup');

if (!empty($this->description) && !v::stringType()->length(null, 254)->validate($this->description))
            throw new InvalidArgumentException(__('Description can not be longer than 254 characters'), 'description');

if ($this->isDisplaySpecific == 0) {
            // Check the name
            $result = $this->getStore()->select('SELECT DisplayGroup FROM displaygroup WHERE DisplayGroup = :displayGroup AND IsDisplaySpecific = 0 AND displayGroupId <> :displayGroupId', [
                'displayGroup' => $this->displayGroup,
                'displayGroupId' => (($this->displayGroupId == null) ? 0 : $this->displayGroupId)
            ]);

if (count($result) > 0)
                throw new DuplicateEntityException(sprintf(__('You already own a display group called "%s". Please choose another name.'), $this->displayGroup));

// If we are dynamic, then make sure we have some criteria
            if ($this->isDynamic == 1 && ($this->dynamicCriteria == '' && $this->dynamicCriteriaTags == ''))
                throw new InvalidArgumentException(__('Dynamic Display Groups must have at least one Criteria specified.'), 'dynamicCriteria');
        }
    }

/**
     * Save
     * @param array $options
     * @throws XiboException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'saveGroup' => true,
            'manageLinks' => true,
            'manageDisplayLinks' => true,
            'manageDynamicDisplayLinks' => true,
            'allowNotify' => true,
            'saveTags' => true
        ], $options);

// Should we allow notification or not?
        $this->allowNotify = $options['allowNotify'];

if ($options['validate'])
            $this->validate();

if ($this->displayGroupId == null || $this->displayGroupId == 0) {
            $this->add();
            $this->loaded = true;
        }
        else if ($options['saveGroup']) {
            $this->edit();
        }

if ($options['saveTags']) {
            // Tags
            if (is_array($this->tags)) {
                foreach ($this->tags as $tag) {
                    /* @var Tag $tag */

$this->getLog()->debug('Assigning tag ' . $tag->tag);

$tag->assignDisplayGroup($this->displayGroupId);
                    $tag->save();
                }
            }

$tag->unassignDisplayGroup($this->displayGroupId);
                    $tag->save();
                }
            }
        }

if ($this->loaded) {

if ($options['manageLinks']) {
                $this->getLog()->debug('Manage links to Display Group');

// Handle any changes in the media linked
                $this->linkMedia();
                $this->unlinkMedia();

// Handle any changes in the layouts linked
                $this->linkLayouts();
                $this->unlinkLayouts();
            }

if ($options['manageDisplayLinks']) {
                // Handle any changes in the displays linked
                $this->manageDisplayLinks($options['manageDynamicDisplayLinks']);

// Handle any group links
                $this->manageDisplayGroupLinks();
            }

} else if ($this->isDynamic && $options['manageDynamicDisplayLinks']) {
            $this->manageDisplayLinks(true);
        }

// Set media incomplete if necessary
        if ($this->notifyRequired)
            $this->notify();
    }

/**
     * Delete
     */
    public function delete()
    {
        // Load everything for the delete
        $this->load();

// Delete things this group can own
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->delete();
        }

foreach ($this->events as $event) {
            /* @var Schedule $event */
            $event->unassignDisplayGroup($this);
            $event->save([
                'audit' => false,
                'validate' => false,
                'deleteOrphaned' => true,
                'notify' => false
            ]);
        }

foreach ($this->tags as $tag) {
            /* @var Tag $tag */
            $tag->unassignDisplayGroup($this->displayGroupId);
            $tag->save();
        }

// Delete assignments
        $this->removeAssignments();

// Delete the Group itself
        $this->getStore()->update('DELETE FROM `displaygroup` WHERE DisplayGroupID = :displayGroupId', ['displayGroupId' => $this->displayGroupId]);
    }

/**
     * Remove any assignments
     */
    public function removeAssignments()
    {
        $this->displays = [];
        $this->displayGroups = [];
        $this->layouts = [];
        $this->media = [];

$this->unlinkDisplays();
        $this->unlinkAllDisplayGroups();
        $this->unlinkLayouts();
        $this->unlinkMedia();

// Delete Notifications
        // NB: notifications aren't modelled as child objects because there could be many thousands of notifications on each
        // displaygroup. We consider the notification to be the parent here and it manages the assignments.
        // This does mean that we might end up with an empty notification (not assigned to anything)
        $this->getStore()->update('DELETE FROM `lknotificationdg` WHERE `displayGroupId` = :displayGroupId', ['displayGroupId' => $this->displayGroupId]);
    }

private function add()
    {
        $this->displayGroupId = $this->getStore()->insert('
          INSERT INTO displaygroup (DisplayGroup, IsDisplaySpecific, Description, `isDynamic`, `dynamicCriteria`, `dynamicCriteriaTags`, `userId`)
            VALUES (:displayGroup, :isDisplaySpecific, :description, :isDynamic, :dynamicCriteria, :dynamicCriteriaTags, :userId)
        ', [
            'displayGroup' => $this->displayGroup,
            'isDisplaySpecific' => $this->isDisplaySpecific,
            'description' => $this->description,
            'isDynamic' => $this->isDynamic,
            'dynamicCriteria' => $this->dynamicCriteria,
            'dynamicCriteriaTags' => $this->dynamicCriteriaTags,
            'userId' => $this->userId
        ]);

// Insert my self link
        $this->getStore()->insert('INSERT INTO `lkdgdg` (`parentId`, `childId`, `depth`) VALUES (:parentId, :childId, 0)', [
            'parentId' => $this->displayGroupId,
            'childId' => $this->displayGroupId
        ]);
    }

private function edit()
    {
        $this->getLog()->debug('Updating Display Group. %s, %d', $this->displayGroup, $this->displayGroupId);

$this->getStore()->update('
          UPDATE displaygroup
            SET DisplayGroup = :displayGroup,
              Description = :description,
              `isDynamic` = :isDynamic,
              `dynamicCriteria` = :dynamicCriteria,
              `dynamicCriteriaTags` = :dynamicCriteriaTags,
              `bandwidthLimit` = :bandwidthLimit,
              `userId` = :userId
           WHERE DisplayGroupID = :displayGroupId
          ', [
            'displayGroup' => $this->displayGroup,
            'description' => $this->description,
            'displayGroupId' => $this->displayGroupId,
            'isDynamic' => $this->isDynamic,
            'dynamicCriteria' => $this->dynamicCriteria,
            'dynamicCriteriaTags' => $this->dynamicCriteriaTags,
            'bandwidthLimit' => $this->bandwidthLimit,
            'userId' => $this->userId
        ]);
    }

/**
     * Manage the links to this display, dynamic or otherwise
     * @var bool $manageDynamic
     * @throws NotFoundException
     */
    private function manageDisplayLinks($manageDynamic = true)
    {
        $difference = [];

if ($this->isDynamic && $manageDynamic) {

$this->getLog()->info('Managing Display Links for Dynamic Display Group %s', $this->displayGroup);

$originalDisplays = ($this->loaded) ? $this->displays : $this->displayFactory->getByDisplayGroupId($this->displayGroupId);

// Update the linked displays based on the filter criteria
            // these displays must be permission checked based on the owner of the group NOT the logged in user
            $this->displays = $this->displayFactory->query(null, ['display' => $this->dynamicCriteria, 'tags' => $this->dynamicCriteriaTags, 'userCheckUserId' => $this->getOwnerId(), 'useRegexForName' => true]);

$this->getLog()->debug('There are %d original displays and %d displays that match the filter criteria now.', count($originalDisplays), count($this->displays));

// Map our arrays to simple displayId lists
            $displayIds = array_map(function ($element) { return $element->displayId; }, $this->displays);
            $originalDisplayIds = array_map(function ($element) { return $element->displayId; }, $originalDisplays);

$difference = array_merge(array_diff($displayIds, $originalDisplayIds), array_diff($originalDisplayIds, $displayIds));

// This is a dynamic display group
            // only manage the links that have changed
            if (count($difference) > 0) {
                $this->getLog()->debug(count($difference) . ' changes in dynamic Displays, will notify individually');

$this->notifyRequired = true;
            } else {
                $this->getLog()->debug('No changes in dynamic Displays, wont notify');

$this->notifyRequired = false;
            }
        }

// Manage the links we've made either way
        // Link
        $this->linkDisplays();

// Check if we should notify
        if ($this->notifyRequired) {
            // We must notify before we unlink
            $this->notify($difference);
        }

// Unlink
        $this->unlinkDisplays();

// Don't do it again
        $this->notifyRequired = false;
    }

/**
     * Manage display group links
     */
    private function manageDisplayGroupLinks()
    {
        $this->linkDisplayGroups();
        $this->unlinkDisplayGroups();

// Check for circular references
        // this is a lazy last minute check as we can't really tell if there is a circular reference unless
        // we've inserted the records already.
        if ($this->getStore()->exists('SELECT depth FROM `lkdgdg` WHERE parentId = :parentId AND childId = parentId AND depth > 0', ['parentId' => $this->displayGroupId]))
            throw new \InvalidArgumentException(__('This assignment creates a circular reference'));
    }

private function linkDisplays()
    {
        foreach ($this->displays as $display) {
            /* @var Display $display */
            $this->getStore()->update('INSERT INTO lkdisplaydg (DisplayGroupID, DisplayID) VALUES (:displayGroupId, :displayId) ON DUPLICATE KEY UPDATE DisplayID = DisplayID', [
                'displayGroupId' => $this->displayGroupId,
                'displayId' => $display->displayId
            ]);
        }
    }

private function unlinkDisplays()
    {
        // Unlink any displays that are NOT in the collection
        $params = ['displayGroupId' => $this->displayGroupId];

$sql = 'DELETE FROM lkdisplaydg WHERE DisplayGroupID = :displayGroupId AND DisplayID NOT IN (0';

$i = 0;
        foreach ($this->displays as $display) {
            /* @var Display $display */
            $i++;
            $sql .= ',:displayId' . $i;
            $params['displayId' . $i] = $display->displayId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

/**
     * Links the display groups that have been added to the OM
     * adding them to the closure table `lkdgdg`
     */
    private function linkDisplayGroups()
    {
        $links = array_udiff($this->displayGroups, $this->originalDisplayGroups, function($a, $b) {
            /**
             * @var DisplayGroup $a
             * @var DisplayGroup $b
             */
            return $a->getId() - $b->getId();
        });

$this->getLog()->debug('Linking %d display groups to Display Group %s', count($links), $this->displayGroup);

foreach ($links as $displayGroup) {
            /* @var DisplayGroup $displayGroup */
            $this->getStore()->insert('
                INSERT INTO lkdgdg (parentId, childId, depth)
                SELECT p.parentId, c.childId, p.depth + c.depth + 1
                  FROM lkdgdg p, lkdgdg c
                 WHERE p.childId = :parentId AND c.parentId = :childId
            ', [
                'parentId' => $this->displayGroupId,
                'childId' => $displayGroup->displayGroupId
            ]);
        }
    }

/**
     * Unlinks the display groups that have been removed from the OM
     * removing them from the closure table `lkdgdg`
     */
    private function unlinkDisplayGroups()
    {
        $links = array_udiff($this->originalDisplayGroups, $this->displayGroups, function($a, $b) {
            /**
             * @var DisplayGroup $a
             * @var DisplayGroup $b
             */
            return $a->getId() - $b->getId();
        });

$this->getLog()->debug('Unlinking ' . count($links) . ' display groups to Display Group ' . $this->displayGroup);

foreach ($links as $displayGroup) {
            /* @var DisplayGroup $displayGroup */
            // Only ever delete 1 because if there are more than 1, we can assume that it is linked at that level from
            // somewhere else
            // https://github.com/xibosignage/xibo/issues/1417
            $linksToDelete = $this->getStore()->select('
                SELECT DISTINCT link.parentId, link.childId, link.depth
                  FROM `lkdgdg` p
                    INNER JOIN `lkdgdg` link
                    ON p.parentId = link.parentId
                    INNER JOIN `lkdgdg` c
                    ON c.childId = link.childId
                 WHERE p.childId = :parentId 
                    AND c.parentId = :childId
                ', [
                'parentId' => $this->displayGroupId,
                'childId' => $displayGroup->displayGroupId
            ]);

foreach ($linksToDelete as $linkToDelete) {
                $this->getStore()->update('
                  DELETE FROM `lkdgdg` 
                   WHERE parentId = :parentId 
                    AND childId = :childId 
                    AND depth = :depth 
                  LIMIT 1
                ', [
                    'parentId' => $linkToDelete['parentId'],
                    'childId' => $linkToDelete['childId'],
                    'depth' => $linkToDelete['depth']
                ]);
            }
        }
    }

/**
     * Unlinks all display groups
     * usually in preparation for a delete
     */
    private function unlinkAllDisplayGroups()
    {
        $this->getStore()->update('
            DELETE link
              FROM `lkdgdg` p, `lkdgdg` link, `lkdgdg` c, `lkdgdg` to_delete
             WHERE p.parentId = link.parentId AND c.childId = link.childId
               AND p.childId  = to_delete.parentId AND c.parentId = to_delete.childId
               AND (to_delete.parentId = :parentId OR to_delete.childId = :childId)
               AND to_delete.depth < 2
        ', [
            'parentId' => $this->displayGroupId,
            'childId' => $this->displayGroupId
        ]);
    }

private function linkMedia()
    {
        foreach ($this->media as $media) {
            /* @var Media $media */
            $this->getStore()->update('INSERT INTO `lkmediadisplaygroup` (mediaid, displaygroupid) VALUES (:mediaId, :displayGroupId) ON DUPLICATE KEY UPDATE mediaid = mediaid', [
                'displayGroupId' => $this->displayGroupId,
                'mediaId' => $media->mediaId
            ]);
        }
    }

private function unlinkMedia()
    {
        // Unlink any media that is NOT in the collection
        $params = ['displayGroupId' => $this->displayGroupId];

$sql = 'DELETE FROM `lkmediadisplaygroup` WHERE DisplayGroupID = :displayGroupId AND mediaId NOT IN (0';

$i = 0;
        foreach ($this->media as $media) {
            /* @var Media $media */
            $i++;
            $sql .= ',:mediaId' . $i;
            $params['mediaId' . $i] = $media->mediaId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }

private function linkLayouts()
    {
        foreach ($this->layouts as $layout) {
            /* @var Layout $media */
            $this->getStore()->update('INSERT INTO `lklayoutdisplaygroup` (layoutid, displaygroupid) VALUES (:layoutId, :displayGroupId) ON DUPLICATE KEY UPDATE layoutid = layoutid', [
                'displayGroupId' => $this->displayGroupId,
                'layoutId' => $layout->layoutId
            ]);
        }
    }

private function unlinkLayouts()
    {
        // Unlink any layout that is NOT in the collection
        $params = ['displayGroupId' => $this->displayGroupId];

$sql = 'DELETE FROM `lklayoutdisplaygroup` WHERE DisplayGroupID = :displayGroupId AND layoutId NOT IN (0';

$i = 0;
        foreach ($this->layouts as $layout) {
            /* @var Layout $layout */
            $i++;
            $sql .= ',:layoutId' . $i;
            $params['layoutId' . $i] = $layout->layoutId;
        }

$sql .= ')';

$this->getStore()->update($sql, $params);
    }
}PK�������qY:(u�������Page.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (Page.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Page
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Page implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of the Page")
     * @var int
     */
    public $pageId;

/**
     * @SWG\Property(description="A code name for the page")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="A user friendly title for this page")
     * @var string
     */
    public $title;

/**
     * @SWG\Property(description="Flag indicating if the page can be used as a homepage")
     * @var int
     */
    public $asHome;

public function getOwnerId()
    {
        return 1;
    }

public function getId()
    {
        return $this->pageId;
    }

public function getName()
    {
        return $this->name;
    }

/**
     * Save
     */
    public function save()
    {
        if ($this->pageId == 0)
            $this->add();
        else
            $this->update();
    }

private function add()
    {
        $this->pageId = $this->getStore()->insert('
            INSERT INTO `pages` (`name`, `title`, `asHome`)
              VALUES (:name, :title, :asHome)
        ', [
            'name' => $this->name,
            'title' => $this->title,
            'asHome' => $this->asHome
        ]);
    }

private function update()
    {
        $this->getStore()->update('
            UPDATE `pages` SET `name` = :name, `title` = :title, `asHome` = :asHome
             WHERE `pageId` = :pageId
        ', [
            'pageId' => $this->pageId,
            'name' => $this->name,
            'title' => $this->title,
            'asHome' => $this->asHome
        ]);
    }
}PK�������qY��Dp<���<�����DataSet.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (DataSet.php)
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Stash\Interfaces\PoolInterface;
use Xibo\Exception\ConfigurationException;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\DataSetColumnFactory;
use Xibo\Factory\DataSetFactory;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\DateServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Service\SanitizerServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DataSet
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DataSet implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The dataSetId")
     * @var int
     */
    public $dataSetId;

/**
     * @SWG\Property(description="The dataSet Name")
     * @var string
     */
    public $dataSet;

/**
     * @SWG\Property(description="The dataSet description")
     * @var string
     */
    public $description;

/**
     * @SWG\Property(description="The userId of the User that owns this DataSet")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="Timestamp indicating the date/time this DataSet was edited last")
     * @var int
     */
    public $lastDataEdit;

/**
     * @SWG\Property(description="The user name of the User that owns this DataSet")
     * @var string
     */
    public $owner;

/**
     * @SWG\Property(description="A comma separated list of Groups/Users that have permission to this DataSet")
     * @var string
     */
    public $groupsWithPermissions;

/**
     * @SWG\Property(description="A code for this Data Set")
     * @var string
     */
    public $code;

/**
     * @SWG\Property(description="Flag to indicate whether this DataSet is a lookup table")
     * @var int
     */
    public $isLookup = 0;

/**
     * @SWG\Property(description="Flag to indicate whether this DataSet is Remote")
     * @var int
     */
    public $isRemote = 0;

/**
     * @SWG\Property(description="Method to fetch the Data, can be GET or POST")
     * @var string
     */
    public $method;

/**
     * @SWG\Property(description="URI to call to fetch Data from. Replacements are {{DATE}}, {{TIME}} and, in case this is a sequencial used DataSet, {{COL.NAME}} where NAME is a ColumnName from the underlying DataSet.")
     * @var string
     */
    public $uri;

/**
     * @SWG\Property(description="Data to send as POST-Data to the remote host with the same Replacements as in the URI.")
     * @var string
     */
    public $postData;

/**
     * @SWG\Property(description="Authentication method, can be none, digest, basic")
     * @var string
     */
    public $authentication;

/**
     * @SWG\Property(description="Username to authenticate with")
     * @var string
     */
    public $username;

/**
     * @SWG\Property(description="Corresponding password")
     * @var string
     */
    public $password;

/**
     * @SWG\Property(description="Comma separated string of custom HTTP headers")
     * @var string
     */
    public $customHeaders;

/**
     * @SWG\Property(description="Time in seconds this DataSet should fetch new Datas from the remote host")
     * @var int
     */
    public $refreshRate;

/**
     * @SWG\Property(description="Time in seconds when this Dataset should be cleared. If here is a lower value than in RefreshRate it will be cleared when the data is refreshed")
     * @var int
     */
    public $clearRate;

/**
     * @SWG\Property(description="DataSetID of the DataSet which should be fetched and present before the Data from this DataSet are fetched")
     * @var int
     */
    public $runsAfter;

/**
     * @SWG\Property(description="Last Synchronisation Timestamp")
     * @var int
     */
    public $lastSync = 0;

/**
     * @SWG\Property(description="Last Clear Timestamp")
     * @var int
     */
    public $lastClear = 0;

/**
     * @SWG\Property(description="Root-Element form JSON where the data are stored in")
     * @var String
     */
    public $dataRoot;

/**
     * @SWG\Property(description="Optional function to use for summarize or count unique fields in a remote request")
     * @var String
     */
    public $summarize;

/**
     * @SWG\Property(description="JSON-Element below the Root-Element on which the consolidation should be applied on")
     * @var String
     */
    public $summarizeField;

/**
     * @SWG\Property(description="The source id for remote dataSet, 1 - JSON, 2 - CSV")
     * @var integer
     */
    public $sourceId;

/**
     * @SWG\Property(description="A flag whether to ignore the first row, for CSV source remote dataSet")
     * @var integer
     */
    public $ignoreFirstRow;

/** @var array Permissions */
    private $permissions = [];

/**
     * @var DataSetColumn[]
     */
    public $columns = [];

private $countLast = 0;

/** @var array Blacklist for SQL */
    private $blackList = array(';', 'INSERT', 'UPDATE', 'SELECT', 'DELETE', 'TRUNCATE', 'TABLE', 'FROM', 'WHERE');

/** @var  SanitizerServiceInterface */
    private $sanitizer;

/** @var  ConfigServiceInterface */
    private $config;

/** @var PoolInterface */
    private $pool;

/** @var  DataSetFactory */
    private $dataSetFactory;

/** @var  DataSetColumnFactory */
    private $dataSetColumnFactory;

/** @var  PermissionFactory */
    private $permissionFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var DateServiceInterface */
    private $date;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param SanitizerServiceInterface $sanitizer
     * @param ConfigServiceInterface $config
     * @param PoolInterface $pool
     * @param DataSetFactory $dataSetFactory
     * @param DataSetColumnFactory $dataSetColumnFactory
     * @param PermissionFactory $permissionFactory
     * @param DisplayFactory $displayFactory
     * @param DateServiceInterface $date
     */
    public function __construct($store, $log, $sanitizer, $config, $pool, $dataSetFactory, $dataSetColumnFactory, $permissionFactory, $displayFactory, $date)
    {
        $this->setCommonDependencies($store, $log);
        $this->sanitizer = $sanitizer;
        $this->config = $config;
        $this->pool = $pool;
        $this->dataSetFactory = $dataSetFactory;
        $this->dataSetColumnFactory = $dataSetColumnFactory;
        $this->permissionFactory = $permissionFactory;
        $this->displayFactory = $displayFactory;
        $this->date = $date;
    }

/**
     * Clone
     */
    public function __clone()
    {
        $this->dataSetId = null;

$this->columns = array_map(function ($object) { return clone $object; }, $this->columns);
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->dataSetId;
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Set the owner of this DataSet
     * @param $userId
     */
    public function setOwner($userId)
    {
        $this->userId = $userId;
    }

/**
     * Get the Count of Records in the last getData()
     * @return int
     */
    public function countLast()
    {
        return $this->countLast;
    }

/**
     * Get Column
     * @param int[Optional] $dataSetColumnId
     * @return DataSetColumn[]|DataSetColumn
     * @throws NotFoundException when the heading is provided and the column cannot be found
     */
    public function getColumn($dataSetColumnId = 0)
    {
        $this->load();

if ($dataSetColumnId != 0) {

foreach ($this->columns as $column) {
                /* @var DataSetColumn $column */
                if ($column->dataSetColumnId == $dataSetColumnId)
                    return $column;
            }

throw new NotFoundException(sprintf(__('Column %s not found'), $dataSetColumnId));

} else {
            return $this->columns;
        }
    }

/**
     * Get Column
     * @param string $dataSetColumn
     * @return DataSetColumn[]|DataSetColumn
     * @throws NotFoundException when the heading is provided and the column cannot be found
     */
    public function getColumnByName($dataSetColumn)
    {
        $this->load();

foreach ($this->columns as $column) {
            /* @var DataSetColumn $column */
            if ($column->heading == $dataSetColumn)
                return $column;
        }

throw new NotFoundException(sprintf(__('Column %s not found'), $dataSetColumn));
    }

/**
     * @param string[] $columns Column Names to select
     * @return array
     */
    public function getUniqueColumnValues($columns)
    {
        $this->load();

$select = '';
        foreach ($columns as $heading) {
            // Check this exists
            $found = false;
            foreach ($this->columns as $column) {
                if ($column->heading == $heading) {
                    // Formula column?
                    if ($column->dataSetColumnTypeId == 2) {
                        $select .= str_replace($this->blackList, '', htmlspecialchars_decode($column->formula, ENT_QUOTES)) . ' AS `' . $column->heading . '`,';
                    }
                    else {
                        $select .= '`' . $column->heading . '`,';
                    }
                    $found = true;
                    break;
                }
            }

if (!$found)
                throw new \InvalidArgumentException(__('Unknown Column ' . $heading));
        }
        $select = rtrim($select, ',');
        // $select is safe

return $this->getStore()->select('SELECT DISTINCT ' . $select . ' FROM `dataset_' . $this->dataSetId . '`', []);
    }

/**
     * Get DataSet Data
     * @param array $filterBy
     * @param array $options
     * @return array
     * @throws NotFoundException
     */
    public function getData($filterBy = [], $options = [])
    {
        $start = $this->sanitizer->getInt('start', 0, $filterBy);
        $size = $this->sanitizer->getInt('size', 0, $filterBy);
        $filter = $this->sanitizer->getParam('filter', $filterBy);
        $ordering = $this->sanitizer->getString('order', $filterBy);
        $displayId = $this->sanitizer->getInt('displayId', 0, $filterBy);

$options = array_merge([
            'includeFormulaColumns' => true,
            'requireTotal' => true
        ], $options);

// Params
        $params = [];

// Sanitize the filter options provided
        // Get the Latitude and Longitude ( might be used in a formula )
        if ($displayId == 0) {
            $displayGeoLocation = "GEOMFROMTEXT('POINT(" . $this->config->getSetting('DEFAULT_LAT') . " " . $this->config->getSetting('DEFAULT_LONG') . ")')";
        }
        else {
            $displayGeoLocation = '(SELECT GeoLocation FROM `display` WHERE DisplayID = :displayId)';
            $params['displayId'] = $displayId;
        }

// Build a SQL statement, based on the columns for this dataset
        $this->load();

$select  = 'SELECT * FROM ( ';
        $body = 'SELECT id';

// Keep track of the columns we are allowed to order by
        $allowedOrderCols = ['id'];

// Are there any client side formulas
        $clientSideFormula = [];

// Select (columns)
        foreach ($this->getColumn() as $column) {
            /* @var DataSetColumn $column */
            $allowedOrderCols[] = $column->heading;
            
            if ($column->dataSetColumnTypeId == 2 && !$options['includeFormulaColumns'])
                continue;

// Formula column?
            if ($column->dataSetColumnTypeId == 2) {

// Is this a client side column?
                if (substr($column->formula, 0, 1) === '$') {
                    $clientSideFormula[] = $column;
                    continue;
                }

$formula = str_replace($this->blackList, '', htmlspecialchars_decode($column->formula, ENT_QUOTES));
                $formula = str_replace('[DisplayId]', $displayId, $formula);

$heading = str_replace('[DisplayGeoLocation]', $displayGeoLocation, $formula) . ' AS `' . $column->heading . '`';
            }
            else {
                $heading = '`' . $column->heading . '`';
            }

$body .= ', ' . $heading;
        }

$body .= ' FROM `dataset_' . $this->dataSetId . '`) dataset WHERE 1 = 1 ';

// Filtering
        if ($filter != '') {
            // Support display filtering.
            $filter = str_replace('[DisplayId]', $displayId, $filter);
            $filter = str_replace($this->blackList, '', $filter);

$body .= ' AND ' . $filter;
        }

// Filter by ID
        if (
            $this->sanitizer->getInt('id', $filterBy) !== null) {
            $body .= ' AND id = :id ';
            $params['id'] = $this->sanitizer->getInt('id', $filterBy);
        }

// Ordering
        $order = '';
        if ($ordering != '') {
            $order = ' ORDER BY ';

$ordering = explode(',', $ordering);

foreach ($ordering as $orderPair) {
                // Sanitize the clause
                $sanitized = str_replace('`', '', str_replace(' ASC', '', str_replace(' DESC', '', $orderPair)));

// Check allowable
                if (!in_array($sanitized, $allowedOrderCols)) {
                    $this->getLog()->info('Disallowed column: ' . $sanitized);
                    continue;
                }

// Substitute
                if (strripos($orderPair, ' DESC')) {
                    $order .= sprintf(' `%s`  DESC,', $sanitized);
                }
                else if (strripos($orderPair, ' ASC')) {
                    $order .= sprintf(' `%s`  ASC,', $sanitized);
                }
                else {
                    $order .= sprintf(' `%s`,', $sanitized);
                }
            }

$order = trim($order, ',');
        }
        else {
            $order = ' ORDER BY id ';
        }

// Limit
        $limit = '';
        if ($start != 0 || $size != 0) {
            // Substitute in

// handle case where lower limit is set to > 0 and upper limit to 0 https://github.com/xibosignage/xibo/issues/2187
            // it is with <= 0 because in some Widgets we calculate the size as upper - lower, https://github.com/xibosignage/xibo/issues/2263.
            if ($start != 0 && $size <= 0) {
                $size = PHP_INT_MAX;
            }

$limit = sprintf(' LIMIT %d, %d ', $start, $size);
        }

$sql = $select . $body . $order . $limit;

$data = $this->getStore()->select($sql, $params);

// If there are limits run some SQL to work out the full payload of rows
        if ($options['requireTotal']) {
            $results = $this->getStore()->select('SELECT COUNT(*) AS total FROM (' . $body, $params);
            $this->countLast = intval($results[0]['total']);
        }

// Are there any client side formulas?
        if (count($clientSideFormula) > 0) {
            $renderedData = [];
            foreach ($data as $item) {
                foreach ($clientSideFormula as $column) {
                    // Run the formula and add the resulting value to the list
                    $value = null;
                    try {
                        if (substr($column->formula, 0, strlen('$dateFormat(')) === '$dateFormat(') {
                            // Pull out the column name and date format
                            $details = explode(',', str_replace(')', '', str_replace('$dateFormat(', '', $column->formula)));

if (isset($details[2])) {
                                $language = str_replace(' ', '', $details[2]);
                            } else {
                                $language = $this->config->getSetting('DEFAULT_LANGUAGE', 'en_GB');
                            }

$this->date->setLocale($language);
                            $value = $this->date->parse($item[$details[0]])->format($details[1]);
                        }
                    } catch (\Exception $e) {
                        $this->getLog()->error('DataSet client side formula error in dataSetId ' . $this->dataSetId . ' with column formula ' . $column->formula);
                    }

$item[$column->heading] = $value;
                }

$renderedData[] = $item;
            }
        } else {
            $renderedData = $data;
        }

return $renderedData;
    }

/**
     * Assign a column
     * @param DataSetColumn $column
     */
    public function assignColumn($column)
    {
        $this->load();

// Set the dataSetId
        $column->dataSetId = $this->dataSetId;

// Set the column order if we need to
        if ($column->columnOrder == 0)
            $column->columnOrder = count($this->columns) + 1;

$this->columns[] = $column;
    }

/**
     * Has Data?
     * @return bool
     */
    public function hasData()
    {
        return $this->getStore()->exists('SELECT id FROM `dataset_' . $this->dataSetId . '` LIMIT 1', []);
    }

/**
     * Returns a Timestamp for the next Synchronisation process.
     * @return int Seconds
     */
    public function getNextSyncTime()
    {
        return $this->lastSync + $this->refreshRate;
    }

/**
     * @return bool
     */
    public function isTruncateEnabled()
    {
        return $this->clearRate !== 0;
    }

/**
     * Returns a Timestamp for the next Clearing process.
     * @return int Seconds
     */
    public function getNextClearTime()
    {
        return $this->lastClear + $this->clearRate;
    }

/**
     * Returns if there is a consolidation field and method present or not.
     * @return boolean
     */
    public function doConsolidate()
    {
        return ($this->summarizeField != null) && ($this->summarizeField != '')
            && ($this->summarize != null) && ($this->summarize != '');
    }

/**
     * Returns the last Part of the Fieldname on which the consolidation should be applied on
     * @return String
     */
    public function getConsolidationField()
    {
        $pos = strrpos($this->summarizeField, '.');
        if ($pos !== false) {
            return substr($this->summarizeField, $pos + 1);
        }
        return $this->summarizeField;
    }

/**
     * Tests if this DataSet contains parameters for getting values on the dependant DataSet
     * @return boolean
     */
    public function containsDependantFieldsInRequest()
    {
        return strpos($this->postData, '{{COL.') !== false || strpos($this->uri, '{{COL.') !== false;
    }

/**
     * Validate
     * @throws InvalidArgumentException
     * @throws DuplicateEntityException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->length(null, 50)->validate($this->dataSet))
            throw new InvalidArgumentException(__('Name must be between 1 and 50 characters'), 'dataSet');

if ($this->description != null && !v::stringType()->length(null, 254)->validate($this->description))
            throw new InvalidArgumentException(__('Description can not be longer than 254 characters'), 'description');

// If we are a remote dataset do some additional checks
        if ($this->isRemote === 1) {
            if (!v::stringType()->notEmpty()->validate($this->uri))
                throw new InvalidArgumentException(__('A remote DataSet must have a URI.'), 'uri');
        }

try {
            $existing = $this->dataSetFactory->getByName($this->dataSet, $this->userId);

if ($this->dataSetId == 0 || $this->dataSetId != $existing->dataSetId)
                throw new DuplicateEntityException(sprintf(__('There is already dataSet called %s. Please choose another name.'), $this->dataSet));
        }
        catch (NotFoundException $e) {
            // This is good
        }
    }

/**
     * Load all known information
     */
    public function load()
    {
        if ($this->loaded || $this->dataSetId == 0)
            return;

// Load Columns
        $this->columns = $this->dataSetColumnFactory->getByDataSetId($this->dataSetId);

// Load Permissions
        $this->permissions = $this->permissionFactory->getByObjectId(get_class($this), $this->getId());

$this->loaded = true;
    }

/**
     * Save this DataSet
     * @param array $options
     * @throws InvalidArgumentException
     * @throws DuplicateEntityException
     */
    public function save($options = [])
    {
        $options = array_merge(['validate' => true, 'saveColumns' => true], $options);

if ($options['validate'])
            $this->validate();

if ($this->dataSetId == 0)
            $this->add();
        else
            $this->edit();

// Columns
        if ($options['saveColumns']) {
            foreach ($this->columns as $column) {
                /* @var \Xibo\Entity\DataSetColumn $column */
                $column->dataSetId = $this->dataSetId;
                $column->save();
            }
        }

// We've been touched
        $this->setActive();

// Notify Displays?
        $this->notify();
    }

/**
     * @param int $time
     * @return $this
     */
    public function saveLastSync($time)
    {
        $this->lastSync = $time;

$this->getStore()->update('UPDATE `dataset` SET lastSync = :lastSync WHERE dataSetId = :dataSetId', [
            'dataSetId' => $this->dataSetId,
            'lastSync' => $this->lastSync
        ]);

return $this;
    }

/**
     * @param int $time
     * @return $this
     */
    public function saveLastClear($time)
    {
        $this->lastSync = $time;

$this->getStore()->update('UPDATE `dataset` SET lastClear = :lastClear WHERE dataSetId = :dataSetId', [
            'dataSetId' => $this->dataSetId,
            'lastClear' => $this->lastClear
        ]);

return $this;
    }

/**
     * Is this DataSet active currently
     * @return bool
     */
    public function isActive()
    {
        $cache = $this->pool->getItem('/dataset/accessed/' . $this->dataSetId);
        return $cache->isHit();
    }

/**
     * Indicate that this DataSet has been accessed recently
     * @return $this
     */
    public function setActive()
    {
        $this->getLog()->debug('Setting ' . $this->dataSetId . ' as active');

$cache = $this->pool->getItem('/dataset/accessed/' . $this->dataSetId);
        $cache->set('true');
        $cache->expiresAfter(intval($this->config->getSetting('REQUIRED_FILES_LOOKAHEAD')) * 1.5);
        $this->pool->saveDeferred($cache);
        return $this;
    }

/**
     * Delete DataSet
     * @throws ConfigurationException
     * @throws InvalidArgumentException
     */
    public function delete()
    {
        $this->load();

if ($this->isLookup)
            throw new ConfigurationException(__('Lookup Tables cannot be deleted'));

// TODO: Make sure we're not used as a dependent DataSet

// Make sure we're able to delete
        if ($this->getStore()->exists('
            SELECT widgetId 
              FROM `widgetoption`
              WHERE `widgetoption`.type = \'attrib\'
                AND `widgetoption`.option = \'dataSetId\'
                AND `widgetoption`.value = :dataSetId
        ', ['dataSetId' => $this->dataSetId])) {
            throw new InvalidArgumentException(__('Cannot delete because DataSet is in use on one or more Layouts.'), 'dataSetId');
        }

// Delete Permissions
        foreach ($this->permissions as $permission) {
            /* @var Permission $permission */
            $permission->deleteAll();
        }

// Delete Columns
        foreach ($this->columns as $column) {
            /* @var \Xibo\Entity\DataSetColumn $column */
            $column->delete();
        }

// Delete any dataSet rss
        $this->getStore()->update('DELETE FROM `datasetrss` WHERE dataSetId = :dataSetId', ['dataSetId' => $this->dataSetId]);

// Delete the data set
        $this->getStore()->update('DELETE FROM `dataset` WHERE dataSetId = :dataSetId', ['dataSetId' => $this->dataSetId]);

// The last thing we do is drop the dataSet table
        $this->dropTable();
    }

/**
     * Delete all data
     */
    public function deleteData()
    {
        // The last thing we do is drop the dataSet table
        $this->getStore()->isolated('TRUNCATE TABLE `dataset_' . $this->dataSetId . '`', []);
        $this->getStore()->isolated('ALTER TABLE `dataset_' . $this->dataSetId . '` AUTO_INCREMENT = 1', []);
    }

/**
     * Add
     */
    private function add()
    {
        $columns = 'DataSet, Description, UserID, `code`, `isLookup`, `isRemote`, `lastDataEdit`, `lastClear`';
        $values = ':dataSet, :description, :userId, :code, :isLookup, :isRemote, :lastDataEdit, :lastClear';

$params = [
            'dataSet' => $this->dataSet,
            'description' => $this->description,
            'userId' => $this->userId,
            'code' => ($this->code == '') ? null : $this->code,
            'isLookup' => $this->isLookup,
            'isRemote' => $this->isRemote,
            'lastDataEdit' => 0,
            'lastClear' => 0
        ];

// Insert the extra columns we expect for a remote DataSet
        if ($this->isRemote === 1) {
            $columns .= ', `method`, `uri`, `postData`, `authentication`, `username`, `password`, `customHeaders`, `refreshRate`, `clearRate`, `runsAfter`, `dataRoot`, `lastSync`, `summarize`, `summarizeField`, `sourceId`, `ignoreFirstRow`';
            $values .= ', :method, :uri, :postData, :authentication, :username, :password, :customHeaders, :refreshRate, :clearRate, :runsAfter, :dataRoot, :lastSync, :summarize, :summarizeField, :sourceId, :ignoreFirstRow';

$params['method'] = $this->method;
            $params['uri'] = $this->uri;
            $params['postData'] = $this->postData;
            $params['authentication'] = $this->authentication;
            $params['username'] = $this->username;
            $params['password'] = $this->password;
            $params['customHeaders'] = $this->customHeaders;
            $params['refreshRate'] = $this->refreshRate;
            $params['clearRate'] = $this->clearRate;
            $params['runsAfter'] = $this->runsAfter;
            $params['dataRoot'] = $this->dataRoot;
            $params['summarize'] = $this->summarize;
            $params['summarizeField'] = $this->summarizeField;
            $params['sourceId'] = $this->sourceId;
            $params['ignoreFirstRow'] = $this->ignoreFirstRow;
            $params['lastSync'] = 0;
        }

// Do the insert
        $this->dataSetId = $this->getStore()->insert('INSERT INTO `dataset` (' . $columns . ') VALUES (' . $values . ')', $params);

// Create the data table for this dataSet
        $this->createTable();
    }

/**
     * Edit
     */
    private function edit()
    {
        $sql = 'DataSet = :dataSet, Description = :description, userId = :userId, lastDataEdit = :lastDataEdit, `code` = :code, `isLookup` = :isLookup, `isRemote` = :isRemote ';
        $params = [
            'dataSetId' => $this->dataSetId,
            'dataSet' => $this->dataSet,
            'description' => $this->description,
            'userId' => $this->userId,
            'lastDataEdit' => $this->lastDataEdit,
            'code' => $this->code,
            'isLookup' => $this->isLookup,
            'isRemote' => $this->isRemote,
        ];

if ($this->isRemote) {
            $sql .= ', method = :method, uri = :uri, postData = :postData, authentication = :authentication, `username` = :username, `password` = :password, `customHeaders` = :customHeaders, refreshRate = :refreshRate, clearRate = :clearRate, runsAfter = :runsAfter, `dataRoot` = :dataRoot, `summarize` = :summarize, `summarizeField` = :summarizeField, `sourceId` = :sourceId, `ignoreFirstRow` = :ignoreFirstRow ';

$this->getStore()->update('UPDATE dataset SET ' . $sql . '  WHERE DataSetID = :dataSetId', $params);
    }

/**
     * Create the realised table structure for this DataSet
     */
    private function createTable()
    {
        // Create the data table for this dataset
        $this->getStore()->update('
          CREATE TABLE `dataset_' . $this->dataSetId . '` (
            `id` int(11) NOT NULL AUTO_INCREMENT,
            PRIMARY KEY (`id`)
          ) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1
        ', []);
    }

private function dropTable()
    {
        $this->getStore()->isolated('DROP TABLE IF EXISTS dataset_' . $this->dataSetId, []);
    }

/**
     * Rebuild the dataSet table
     * @throws XiboException
     */
    public function rebuild()
    {
        $this->load();

// Drop the data table
        $this->dropTable();

// Add the data table
        $this->createTable();

foreach ($this->columns as $column) {
            /* @var \Xibo\Entity\DataSetColumn $column */
            $column->dataSetId = $this->dataSetId;
            $column->save(['rebuilding' => true]);
        }
    }

/**
     * Notify displays of this campaign change
     */
    public function notify()
    {
        $this->getLog()->debug('DataSet ' . $this->dataSetId . ' wants to notify');

$this->displayFactory->getDisplayNotifyService()->collectNow()->notifyByDataSetId($this->dataSetId);
    }

/**
     * Add a row
     * @param array $row
     * @return int
     */
    public function addRow($row)
    {
        $this->getLog()->debug('Adding row ' . var_export($row, true));

// Update the last edit date on this dataSet
        $this->lastDataEdit = time();

// Build a query to insert
        $keys = array_keys($row);
        $keys[] = 'id';

$values = array_values($row);
        $values[] = NULL;

$sql = 'INSERT INTO `dataset_' . $this->dataSetId . '` (`' . implode('`, `', $keys) . '`) VALUES (' . implode(',', array_fill(0, count($values), '?')) . ')';

return $this->getStore()->insert($sql, $values);
    }

/**
     * Edit a row
     * @param int $rowId
     * @param array $row
     */
    public function editRow($rowId, $row)
    {
        $this->getLog()->debug('Editing row %s', var_export($row, true));

// Update the last edit date on this dataSet
        $this->lastDataEdit = time();

// Params
        $params = ['id' => $rowId];

// Generate a SQL statement
        $sql = 'UPDATE `dataset_' . $this->dataSetId . '` SET';

$i = 0;
        foreach ($row as $key => $value) {
            $i++;
            $sql .= ' `' . $key . '` = :value' . $i . ',';
            $params['value' . $i] = $value;
        }

$sql = rtrim($sql, ',');

$sql .= ' WHERE `id` = :id ';

$this->getStore()->update($sql, $params);
    }

/**
     * Delete Row
     * @param $rowId
     */
    public function deleteRow($rowId)
    {
        $this->lastDataEdit = time();

$this->getStore()->update('DELETE FROM `dataset_' . $this->dataSetId . '` WHERE id = :id', [
            'id' => $rowId
        ]);
    }

/**
     * Copy Row
     * @param int $dataSetIdSource
     * @param int $dataSetIdTarget
     */
    public function copyRows($dataSetIdSource, $dataSetIdTarget)
    {
        $this->getStore()->insert('INSERT INTO `dataset_' . $dataSetIdTarget . '`  SELECT * FROM `dataset_' . $dataSetIdSource . '` ' ,[]);
    }
}PK�������qY�f�Z��Z����ApplicationRedirectUri.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (ApplicationRedirectUri.php)
 */

namespace Xibo\Entity;

use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class ApplicationRedirectUri
 * @package Xibo\Entity
 */
class ApplicationRedirectUri implements \JsonSerializable
{
    use EntityTrait;

/**
     * @var int
     */
    public $id;

/**
     * @var string
     */
    public $clientId;

/**
     * @var string
     */
    public $redirectUri;

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->id;
    }

/**
     * Save
     */
    public function save()
    {
        if ($this->id == null)
            $this->add();
        else
            $this->edit();
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM `oauth_client_redirect_uris` WHERE `id` = :id', ['id' => $this->id]);
    }

private function add()
    {
        $this->id = $this->getStore()->insert('
            INSERT INTO `oauth_client_redirect_uris` (`client_id`, `redirect_uri`)
              VALUES (:clientId, :redirectUri)
        ', [
            'clientId' => $this->clientId,
            'redirectUri' => $this->redirectUri
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
            UPDATE `oauth_client_redirect_uris`
                SET `redirect_uri` = :redirectUri
              WHERE `id` = :id
        ',[
            'id' => $this->id,
            'redirectUri' => $this->redirectUri
        ]);
    }
}PK�������qY�I��	���	����ScheduleExclusion.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class ScheduleExclusion
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class ScheduleExclusion implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="Excluded Schedule ID")
     * @var int
     */
    public $scheduleExclusionId;

/**
     * @SWG\Property(description="The eventId that this Excluded Schedule applies to")
     * @var int
     */
    public $eventId;

/**
     * @SWG\Property(
     *  description="A Unix timestamp representing the from date of an excluded recurring event in CMS time."
     * )
     * @var int
     */
    public $fromDt;

/**
     * @SWG\Property(
     *  description="A Unix timestamp representing the to date of an excluded recurring event in CMS time."
     * )
     * @var int
     */
    public $toDt;

public function save()
    {
        $this->getStore()->insert('INSERT INTO `scheduleexclusions` (`eventId`, `fromDt`, `toDt`) VALUES (:eventId, :fromDt, :toDt)', [
            'eventId' => $this->eventId,
            'fromDt' => $this->fromDt,
            'toDt' => $this->toDt,
        ]);
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM `scheduleexclusions` WHERE `scheduleExclusionId` = :scheduleExclusionId', [
            'scheduleExclusionId' => $this->scheduleExclusionId
        ]);
    }
}PK�������qY5���S��S����DataType.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (DataType.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class DataType
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class DataType implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID for this DataType")
     * @var int
     */
    public $dataTypeId;

/**
     * @SWG\Property(description="The Name for this DataType")
     * @var string
     */
    public $dataType;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     */
    public function __construct($store, $log)
    {
        $this->setCommonDependencies($store, $log);
    }
}PK�������qY�q|��������Permission.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (Permission.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Permission
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Permission implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Permission Record")
     * @var int
     */
    public $permissionId;

/**
     * @SWG\Property(description="The Entity ID that this Permission refers to")
     * @var int
     */
    public $entityId;

/**
     * @SWG\Property(description="The User Group ID that this permission refers to")
     * @var int
     */
    public $groupId;

/**
     * @SWG\Property(description="The object ID that this permission refers to")
     * @var int
     */
    public $objectId;

/**
     * @SWG\Property(description="A flag indicating whether the groupId refers to a user specific group")
     * @var int
     */
    public $isUser;

/**
     * @SWG\Property(description="The entity name that this refers to")
     * @var string
     */
    public $entity;

/**
     * @SWG\Property(description="Legacy for when the Object ID is a string")
     * @var string
     */
    public $objectIdString;

/**
     * @SWG\Property(description="The group name that this refers to")
     * @var string
     */
    public $group;

/**
     * @SWG\Property(description="A flag indicating whether view permission is granted")
     * @var int
     */
    public $view;

/**
     * @SWG\Property(description="A flag indicating whether edit permission is granted")
     * @var int
     */
    public $edit;

/**
     * @SWG\Property(description="A flag indicating whether delete permission is granted")
     * @var int
     */
    public $delete;

/**
     * @SWG\Property(description="A flag indicating whether modify permission permission is granted.")
     * @var int
     */
    public $modifyPermissions;

public function __clone()
    {
        $this->permissionId = null;
    }

public function save()
    {
        if ($this->permissionId == 0) {
            // Check there is something to add
            if ($this->view != 0 || $this->edit != 0 || $this->delete != 0) {
                $this->getLog()->debug('Adding Permission for %s, %d. GroupId: %d - View = %d, Edit = %d, Delete = %d', $this->entity, $this->objectId, $this->groupId, $this->view, $this->edit, $this->delete);
                $this->add();
            }
        } else {
            $this->getLog()->debug('Editing Permission for %s, %d. GroupId: %d - View = %d, Edit = %d, Delete = %d', $this->entity, $this->objectId, $this->groupId, $this->view, $this->edit, $this->delete);
            // Are we all 0 permissions
            if ($this->view == 0 && $this->edit == 0 && $this->delete == 0)
                $this->delete();
            else
                $this->update();
        }
    }

private function add()
    {
        $this->permissionId = $this->getStore()->insert('INSERT INTO `permission` (`entityId`, `groupId`, `objectId`, `view`, `edit`, `delete`) VALUES (:entityId, :groupId, :objectId, :view, :edit, :delete)', array(
            'entityId' => $this->entityId,
            'objectId' => $this->objectId,
            'groupId' => $this->groupId,
            'view' => $this->view,
            'edit' => $this->edit,
            'delete' => $this->delete,
        ));
    }

private function update()
    {
        $this->getStore()->update('UPDATE `permission` SET `view` = :view, `edit` = :edit, `delete` = :delete WHERE `entityId` = :entityId AND `groupId` = :groupId AND `objectId` = :objectId', array(
            'entityId' => $this->entityId,
            'objectId' => $this->objectId,
            'groupId' => $this->groupId,
            'view' => $this->view,
            'edit' => $this->edit,
            'delete' => $this->delete,
        ));
    }

public function delete()
    {
        $this->getLog()->debug('Deleting Permission for %s, %d', $this->entity, $this->objectId);
        $this->getStore()->update('DELETE FROM `permission` WHERE entityId = :entityId AND objectId = :objectId AND groupId = :groupId', array(
            'entityId' => $this->entityId,
            'objectId' => $this->objectId,
            'groupId' => $this->groupId
        ));
    }

public function deleteAll()
    {
        $this->getStore()->update('DELETE FROM `permission` WHERE entityId = :entityId AND objectId = :objectId', array(
            'entityId' => $this->entityId,
            'objectId' => $this->objectId,
        ));
    }
}PK�������qYK�˵��������ReportSchedule.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;
use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class ReportSchedule
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class ReportSchedule implements \JsonSerializable
{
    use EntityTrait;

public static $SCHEDULE_DAILY   = '0 0 * * *';
    public static $SCHEDULE_WEEKLY  = '0 0 * * 1';
    public static $SCHEDULE_MONTHLY = '0 0 1 * *';
    public static $SCHEDULE_YEARLY  = '0 0 1 1 *';

public $reportScheduleId;
    public $lastSavedReportId;
    public $name;
    public $reportName;
    public $filterCriteria;
    public $schedule;
    public $lastRunDt = 0;
    public $previousRunDt;
    public $createdDt;
    public $isActive = 1;
    public $message;

/**
     * @SWG\Property(description="The username of the User that owns this report schedule")
     * @var string
     */
    public $owner;

/**
     * @SWG\Property(description="The ID of the User that owns this report schedule")
     * @var int
     */
    public $userId;

/**
     * Save
     * @param array $options
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true
        ], $options);

if ($options['validate'])
            $this->validate();

if ($this->reportScheduleId == null) {
            $this->add();
            $this->getLog()->debug('Adding report schedule');
        }
        else
        {
            $this->edit();
            $this->getLog()->debug('Editing a report schedule');
        }
    }

/**
     * Validate
     * @throws InvalidArgumentException
     */
    public function validate()
    {
        if (!v::stringType()->notEmpty()->validate($this->name))
            throw new InvalidArgumentException(__('Missing name'), 'name');
    }

/**
     * Delete
     */
    public function delete()
    {
        $this->getStore()->update('DELETE FROM `reportschedule` WHERE `reportScheduleId` = :reportScheduleId', ['reportScheduleId' => $this->reportScheduleId]);
    }

private function add()
    {
        $this->reportScheduleId = $this->getStore()->insert('
            INSERT INTO `reportschedule` (`name`, `lastSavedReportId`, `reportName`, `schedule`, `lastRunDt`, `previousRunDt`, `filterCriteria`, `userId`, `isActive`, `message`, `createdDt`) VALUES
                                         (:name,  :lastSavedReportId,  :reportName,  :schedule,  :lastRunDt,  :previousRunDt,  :filterCriteria,  :userId,  :isActive,  :message,  :createdDt)
        ', [
            'name' => $this->name,
            'lastSavedReportId' => $this->lastSavedReportId,
            'reportName' => $this->reportName,
            'schedule' => $this->schedule,
            'lastRunDt' => $this->lastRunDt,
            'previousRunDt' => $this->previousRunDt,
            'filterCriteria' => $this->filterCriteria,
            'userId' => $this->userId,
            'isActive' => $this->isActive,
            'message' => $this->message,
            'createdDt' => $this->createdDt,
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $this->getStore()->update('
          UPDATE `reportschedule`
            SET `name` = :name,
            `lastSavedReportId` = :lastSavedReportId,
            `reportName` = :reportName,
            `schedule` = :schedule,
            `lastRunDt` = :lastRunDt,
            `previousRunDt` = :previousRunDt,
            `filterCriteria` = :filterCriteria,
            `userId` = :userId,
            `isActive` = :isActive,
            `message` = :message,
            `createdDt` = :createdDt            
           WHERE reportScheduleId = :reportScheduleId', [
            'reportScheduleId' => $this->reportScheduleId,
            'lastSavedReportId' => $this->lastSavedReportId,
            'name' => $this->name,
            'reportName' => $this->reportName,
            'schedule' => $this->schedule,
            'lastRunDt' => $this->lastRunDt,
            'previousRunDt' => $this->previousRunDt,
            'filterCriteria' => $this->filterCriteria,
            'userId' => $this->userId,
            'isActive' => $this->isActive,
            'message' => $this->message,
            'createdDt' => $this->createdDt
        ]);
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->reportScheduleId;
    }

/**
     * Get Owner Id
     * @return int
     */
    public function getOwnerId()
    {
        return $this->userId;
    }

/**
     * Returns the last saved report id
     * @return integer
     */
    public function getLastSavedReportId()
    {
        return $this->lastSavedReportId;
    }
}PK�������qY&?R��������UserNotification.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2016 Spring Signage Ltd
 * (UserGroupNotification.php)
 */

namespace Xibo\Entity;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class UserGroupNotification
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class UserNotification implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(
     *  description="The User Id"
     * )
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(
     *  description="The Notification Id"
     * )
     * @var int
     */
    public $notificationId;

/**
     * @SWG\Property(
     *  description="Release Date expressed as Unix Timestamp"
     * )
     * @var int
     */
    public $releaseDt;

/**
     * @SWG\Property(
     *  description="Read Date expressed as Unix Timestamp"
     * )
     * @var int
     */
    public $readDt;

/**
     * @SWG\Property(
     *  description="Email Date expressed as Unix Timestamp"
     * )
     * @var int
     */
    public $emailDt;

/**
     * @SWG\Property(
     *  description="A flag indicating whether to show as read or not"
     * )
     * @var int
     */
    public $read;

/**
     * @SWG\Property(
     *  description="The subject"
     * )
     * @var string
     */
    public $subject;

/**
     * @SWG\Property(
     *  description="The body"
     * )
     * @var string
     */
    public $body;

/**
     * @SWG\Property(
     *  description="Should the notification interrupt the CMS UI on navigate/login"
     * )
     * @var int
     */
    public $isInterrupt;

/**
     * @SWG\Property(
     *  description="Flag for system notification"
     * )
     * @var int
     */
    public $isSystem;

/**
     * @var string
     */
    public $email;

/**
     * @var string
     */
    public $filename;

/**
     * @var string
     */
    public $originalFileName;

/**
     * @var string
     */
    public $nonusers;

/**
     * Set Read
     * @param int $readDt
     */
    public function setRead($readDt)
    {
        $this->read = 1;

if ($this->readDt == 0)
            $this->readDt = $readDt;
    }

/**
     * Set unread
     */
    public function setUnread()
    {
        $this->read = 0;
    }

/**
     * Set Emailed
     * @param int $emailDt
     */
    public function setEmailed($emailDt)
    {
        if ($this->emailDt == 0)
            $this->emailDt = $emailDt;
    }

/**
     * Save
     */
    public function save()
    {
        $this->getStore()->update('UPDATE `lknotificationuser` SET `read` = :read, readDt = :readDt, emailDt = :emailDt WHERE notificationId = :notificationId AND userId = :userId', [
            'read' => $this->read,
            'readDt' => $this->readDt,
            'emailDt' => $this->emailDt,
            'notificationId' => $this->notificationId,
            'userId' => $this->userId
        ]);
    }
}PK�������qY{����������Help.phpnu��[�����������<?php
/*
 * Spring Signage Ltd - http://www.springsignage.com
 * Copyright (C) 2015 Spring Signage Ltd
 * (Help.php)
 */

namespace Xibo\Entity;
use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Help
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Help
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Help Record")
     * @var int
     */
    public $helpId;

/**
     * @SWG\Property(description="The topic for this Help Record")
     * @var string
     */
    public $topic;

/**
     * @SWG\Property(description="The Category for this Help Record")
     * @var string
     */
    public $category;

/**
     * @SWG\Property(description="The Link to the Manual for this Help Record")
     * @var string
     */
    public $link;

public function getId()
    {
        return $this->helpId;
    }

public function getOwnerId()
    {
        return 1;
    }

public function validate()
    {
        if (!v::stringType()->notEmpty()->length(1, 254)->validate($this->topic))
            throw new InvalidArgumentException(__('Topic is a required field. It must be between 1 and 254 characters.'), 'topic');

if (!v::stringType()->notEmpty()->length(1, 254)->validate($this->category))
            throw new InvalidArgumentException(__('Category is a required field. It must be between 1 and 254 characters.'), 'category');

if (!v::stringType()->notEmpty()->length(1, 254)->validate($this->link))
            throw new InvalidArgumentException(__('Link is a required field. It must be between 1 and 254 characters.'), 'link');
    }

public function save($validate = true)
    {
        if ($validate)
            $this->validate();

if ($this->helpId == null || $this->helpId == 0)
            $this->add();
        else
            $this->edit();
    }

public function delete()
    {
        $this->getStore()->update('DELETE FROM `help` WHERE HelpID = :helpId', [
            'helpId' => $this->helpId
        ]);
    }

private function add()
    {
        $this->helpId = $this->getStore()->insert('INSERT INTO `help` (Topic, Category, Link) VALUES (:topic, :category, :link)', [
            'topic' => $this->topic,
            'category' => $this->category,
            'link' => $this->link
        ]);
    }

private function edit()
    {
        $this->getStore()->update('UPDATE `help` SET Topic = :topic, Category = :category, Link = :link WHERE HelpID = :helpId', [
            'helpId' => $this->helpId,
            'topic' => $this->topic,
            'category' => $this->category,
            'link' => $this->link
        ]);
    }
}PK�������qYl�Q��������ScheduleReminder.phpnu��[�����������<?php

namespace Xibo\Entity;

use Xibo\Exception\XiboException;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\ScheduleReminderFactory;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
* Class ScheduleReminder
* @package Xibo\Entity
*
* @SWG\Definition()
*/
class ScheduleReminder implements \JsonSerializable
{
    use EntityTrait;

public static $TYPE_MINUTE = 1;
    public static $TYPE_HOUR = 2;
    public static $TYPE_DAY = 3;
    public static $TYPE_WEEK = 4;
    public static $TYPE_MONTH = 5;

public static $OPTION_BEFORE_START = 1;
    public static $OPTION_AFTER_START = 2;
    public static $OPTION_BEFORE_END = 3;
    public static $OPTION_AFTER_END = 4;

public static $MINUTE = 60;
    public static $HOUR = 3600;
    public static $DAY = 86400;
    public static $WEEK = 604800;
    public static $MONTH = 30 * 86400;

/**
     * @SWG\Property(description="Schedule Reminder ID")
     * @var int
     */
    public $scheduleReminderId;

/**
     * @SWG\Property(description="The event ID of the schedule reminder")
     * @var int
     */
    public $eventId;

/**
     * @SWG\Property(description="An integer number to define minutes, hours etc.")
     * @var int
     */
    public $value;

/**
     * @SWG\Property(description="The type of the reminder (i.e. Minute, Hour, Day, Week, Month)")
     * @var int
     */
    public $type;

/**
     * @SWG\Property(description="The options regarding sending a reminder for an event. (i.e., Before start, After start, Before end, After end)")
     * @var int
     */
    public $option;

/**
     * @SWG\Property(description="Email flag for schedule reminder")
     * @var int
     */
    public $isEmail;

/**
     * @SWG\Property(description="A date that indicates the reminder date")
     * @var int
     */
    public $reminderDt;

/**
     * @SWG\Property(description="Last reminder date a reminder was sent")
     * @var int
     */
    public $lastReminderDt = 0;

/**
     * @var ConfigServiceInterface
     */
    private $config;

/**
     * @var ScheduleReminderFactory
     */
    private $scheduleReminderFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $config
     * @param ScheduleReminderFactory $scheduleReminderFactory
     */
    public function __construct($store, $log, $config, $scheduleReminderFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->config = $config;
        $this->scheduleReminderFactory = $scheduleReminderFactory;
    }

/**
     * Add
     */
    private function add()
    {
        $this->scheduleReminderId = $this->getStore()->insert('
            INSERT INTO `schedulereminder` (`eventId`, `value`, `type`, `option`, `reminderDt`, `isEmail`, `lastReminderDt`)
              VALUES (:eventId, :value, :type, :option, :reminderDt, :isEmail, :lastReminderDt)
        ', [
            'eventId' => $this->eventId,
            'value' => $this->value,
            'type' => $this->type,
            'option' => $this->option,
            'reminderDt' => $this->reminderDt,
            'isEmail' => $this->isEmail,
            'lastReminderDt' => $this->lastReminderDt,
        ]);
    }

/**
     * Edit
     */
    private function edit()
    {
        $sql = '
          UPDATE `schedulereminder`
            SET `eventId` = :eventId,
                `type` = :type,
                `value` = :value,
                `option` = :option,
                `reminderDt` = :reminderDt,
                `isEmail` = :isEmail,
                `lastReminderDt` = :lastReminderDt
           WHERE scheduleReminderId = :scheduleReminderId
        ';

$params = [
            'eventId' => $this->eventId,
            'type' => $this->type,
            'value' => $this->value,
            'option' => $this->option,
            'reminderDt' => $this->reminderDt,
            'isEmail' => $this->isEmail,
            'lastReminderDt' => $this->lastReminderDt,
            'scheduleReminderId' => $this->scheduleReminderId,
        ];

$this->getStore()->update($sql, $params);
    }

/**
     * Delete
     * @throws XiboException
     */
    public function delete()
    {
        $this->load();

$this->getLog()->debug('Delete schedule reminder: '.$this->scheduleReminderId);
        $this->getStore()->update('DELETE FROM `schedulereminder` WHERE `scheduleReminderId` = :scheduleReminderId', [
            'scheduleReminderId' => $this->scheduleReminderId
        ]);
    }

/**
     * Load
     */
    public function load()
    {
        if ($this->loaded || $this->scheduleReminderId == null)
            return;

$this->loaded = true;
    }

/**
     * Get Id
     * @return int
     */
    public function getId()
    {
        return $this->scheduleReminderId;
    }

/**
     * Get Reminder Date
     * @return int
     */
    public function getReminderDt()
    {
        return $this->reminderDt;
    }

/**
     * Save
     */
    public function save()
    {
        if ($this->scheduleReminderId == null || $this->scheduleReminderId == 0)
            $this->add();
        else
            $this->edit();
    }
}PK�������qY�z
xλ��λ����User.phpnu��[�����������<?php
/**
 * Copyright (C) 2019 Xibo Signage Ltd
 *
 * Xibo - Digital Signage - http://www.xibo.org.uk
 *
 * This file is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace Xibo\Entity;

use League\OAuth2\Server\Entity\ScopeEntity;
use Respect\Validation\Validator as v;
use Xibo\Exception\AccessDeniedException;
use Xibo\Exception\ConfigurationException;
use Xibo\Exception\DuplicateEntityException;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Exception\LibraryFullException;
use Xibo\Exception\NotFoundException;
use Xibo\Exception\XiboException;
use Xibo\Factory\ApplicationScopeFactory;
use Xibo\Factory\CampaignFactory;
use Xibo\Factory\DataSetFactory;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\DisplayGroupFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\PageFactory;
use Xibo\Factory\PermissionFactory;
use Xibo\Factory\PlayerVersionFactory;
use Xibo\Factory\PlaylistFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Factory\UserFactory;
use Xibo\Factory\UserGroupFactory;
use Xibo\Factory\UserOptionFactory;
use Xibo\Factory\WidgetFactory;
use Xibo\Helper\Pbkdf2Hash;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class User
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class User implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this User")
     * @var int
     */
    public $userId;

/**
     * @SWG\Property(description="The user name")
     * @var string
     */
    public $userName;

/**
     * @SWG\Property(description="The user type ID")
     * @var int
     */
    public $userTypeId;

/**
     * @SWG\Property(description="Flag indicating whether this user is logged in or not")
     * @var int
     */
    public $loggedIn;

/**
     * @SWG\Property(description="Email address of the user used for email alerts")
     * @var string
     */
    public $email;

/**
     * @SWG\Property(description="The pageId of the Homepage for this User")
     * @var int
     */
    public $homePageId;

/**
     * @SWG\Property(description="A timestamp indicating the time the user last logged into the CMS")
     * @var int
     */
    public $lastAccessed;

/**
     * @SWG\Property(description="A flag indicating whether this user has see the new user wizard")
     * @var int
     */
    public $newUserWizard = 0;

/**
     * @SWG\Property(description="A flag indicating whether the user is retired")
     * @var int
     */
    public $retired;

private $CSPRNG;
    private $password;

/**
     * @SWG\Property(description="A flag indicating whether password change should be forced for this user")
     * @var int
     */
    public $isPasswordChangeRequired = 0;

/**
     * @SWG\Property(description="The users user group ID")
     * @var int
     */
    public $groupId;

/**
     * @SWG\Property(description="The users group name")
     * @var int
     */
    public $group;

/**
     * @SWG\Property(description="The users library quota in bytes")
     * @var int
     */
    public $libraryQuota;

/**
     * @SWG\Property(description="First Name")
     * @var string
     */
    public $firstName;

/**
     * @SWG\Property(description="Last Name")
     * @var string
     */
    public $lastName;

/**
     * @SWG\Property(description="Phone Number")
     * @var string
     */
    public $phone;

/**
     * @SWG\Property(description="Reference field 1")
     * @var string
     */
    public $ref1;

/**
     * @SWG\Property(description="Reference field 2")
     * @var string
     */
    public $ref2;

/**
     * @SWG\Property(description="Reference field 3")
     * @var string
     */
    public $ref3;

/**
     * @SWG\Property(description="Reference field 4")
     * @var string
     */
    public $ref4;

/**
     * @SWG\Property(description="Reference field 5")
     * @var string
     */
    public $ref5;

/**
     * @SWG\Property(description="An array of user groups this user is assigned to")
     * @var UserGroup[]
     */
    public $groups = [];

/**
     * @SWG\Property(description="An array of Campaigns for this User")
     * @var Campaign[]
     */
    public $campaigns = [];

/**
     * @SWG\Property(description="An array of Layouts for this User")
     * @var Layout[]
     */
    public $layouts = [];

/**
     * @SWG\Property(description="An array of Media for this user")
     * @var Media[]
     */
    public $media = [];

/**
     * @SWG\Property(description="An array of Scheduled Events for this User")
     * @var Schedule[]
     */
    public $events = [];

/**
     * @SWG\Property(description="An array of Playlists owned by this User")
     * @var Playlist[]
     */
    public $playlists = [];

/**
     * @SWG\Property(description="The name of home page")
     * @var string
     */
    public $homePage;

/**
     * @SWG\Property(description="Does this Group receive system notifications.")
     * @var int
     */
    public $isSystemNotification = 0;

/**
     * @SWG\Property(description="Does this Group receive system notifications.")
     * @var int
     */
    public $isDisplayNotification = 0;

/**
     * @SWG\Property(description="The two factor type id")
     * @var int
     */
    public $twoFactorTypeId;

/**
     * @SWG\Property(description="Two Factor authorisation shared secret for this user")
     * @var string
     */
    public $twoFactorSecret;

/**
     * @SWG\Property(description="Two Factor authorisation recovery codes", @SWG\Items(type="string"))
     * @var array
     */
    public $twoFactorRecoveryCodes = [];

/**
     * @SWG\Property(description="Should we show content added by standard users in relevant grids (1) or content added by the DOOH user? (2). Super admins have an option to change this in their User profile. ")
     * @var int
     */
    public $showContentFrom = 1;

/**
     * @var UserOption[]
     */
    private $userOptions = [];

/**
     * User options that have been removed
     * @var \Xibo\Entity\UserOption[]
     */
    private $userOptionsRemoved = [];

/**
     * Cached Permissions
     * @var array[Permission]
     */
    private $permissionCache = array();

/**
     * Cached Page Permissions
     * @var array[Page]
     */
    private $pagePermissionCache = null;

/**
     * @var ConfigServiceInterface
     */
    private $configService;

/**
     * @var PageFactory
     */
    private $pageFactory;

/**
     * @var UserFactory
     */
    private $userFactory;

/**
     * @var UserGroupFactory
     */
    private $userGroupFactory;

/**
     * @var PermissionFactory
     */
    private $permissionFactory;

/**
     * @var CampaignFactory
     */
    private $campaignFactory;

/**
     * @var LayoutFactory
     */
    private $layoutFactory;

/**
     * @var MediaFactory
     */
    private $mediaFactory;

/**
     * @var ScheduleFactory
     */
    private $scheduleFactory;

/**
     * @var UserOptionFactory
     */
    private $userOptionFactory;

/** @var  DisplayFactory */
    private $displayFactory;

/** @var  ApplicationScopeFactory */
    private $applicationScopeFactory;

/** @var  DisplayGroupFactory */
    private $displayGroupFactory;

/** @var WidgetFactory */
    private $widgetFactory;

/** @var PlayerVersionFactory */
    private $playerVersionFactory;

/** @var PlaylistFactory */
    private $playlistFactory;

/** @var DataSetFactory */
    private $dataSetFactory;

/**
     * Entity constructor.
     * @param StorageServiceInterface $store
     * @param LogServiceInterface $log
     * @param ConfigServiceInterface $configService
     * @param UserFactory $userFactory
     * @param PermissionFactory $permissionFactory
     * @param UserOptionFactory $userOptionFactory
     * @param ApplicationScopeFactory $applicationScopeFactory
     */
    public function __construct($store,
                                $log,
                                $configService,
                                $userFactory,
                                $permissionFactory,
                                $userOptionFactory,
                                $applicationScopeFactory)
    {
        $this->setCommonDependencies($store, $log);

$this->configService = $configService;
        $this->userFactory = $userFactory;
        $this->permissionFactory = $permissionFactory;
        $this->userOptionFactory = $userOptionFactory;
        $this->applicationScopeFactory = $applicationScopeFactory;
        $this->excludeProperty('twoFactorSecret');
        $this->excludeProperty('twoFactorRecoveryCodes');
    }

/**
     * Set the user group factory
     * @param UserGroupFactory $userGroupFactory
     * @param PageFactory $pageFactory
     * @return $this
     */
    public function setChildAclDependencies($userGroupFactory, $pageFactory)
    {
        // Assert myself on these factories
        $userGroupFactory->setAclDependencies($this, $this->userFactory);
        $pageFactory->setAclDependencies($this, $this->userFactory);
        $this->userFactory->setAclDependencies($this, $this->userFactory);

$this->userGroupFactory = $userGroupFactory;
        $this->pageFactory = $pageFactory;
        return $this;
    }

/**
     * Set Child Object Depencendies
     *  must be set before calling Load with all objects
     * @param CampaignFactory $campaignFactory
     * @param LayoutFactory $layoutFactory
     * @param MediaFactory $mediaFactory
     * @param ScheduleFactory $scheduleFactory
     * @param DisplayFactory $displayFactory
     * @param DisplayGroupFactory $displayGroupFactory
     * @param WidgetFactory $widgetFactory
     * @param PlayerVersionFactory $playerVersionFactory
     * @param PlaylistFactory $playlistFactory
     * @return $this
     */
    public function setChildObjectDependencies($campaignFactory, $layoutFactory, $mediaFactory, $scheduleFactory, $displayFactory, $displayGroupFactory, $widgetFactory, $playerVersionFactory, $playlistFactory, $dataSetFactory)
    {
        $this->campaignFactory = $campaignFactory;
        $this->layoutFactory = $layoutFactory;
        $this->mediaFactory = $mediaFactory;
        $this->scheduleFactory = $scheduleFactory;
        $this->displayFactory = $displayFactory;
        $this->displayGroupFactory = $displayGroupFactory;
        $this->widgetFactory = $widgetFactory;
        $this->playerVersionFactory = $playerVersionFactory;
        $this->playlistFactory = $playlistFactory;
        $this->dataSetFactory = $dataSetFactory;
        return $this;
    }

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('User %s. userId: %d, UserTypeId: %d, homePageId: %d, email = %s', $this->userName, $this->userId, $this->userTypeId, $this->homePageId, $this->email);
    }

/**
     * @return string
     */
    private function hash()
    {
        return md5(json_encode($this));
    }

/**
     * @return int
     */
    public function getOwnerId()
    {
        return $this->getId();
    }

/**
     * @return int
     */
    public function getId()
    {
        return $this->userId;
    }

/**
     * Get Option
     * @param string $option
     * @return UserOption
     * @throws NotFoundException
     */
    public function getOption($option)
    {
        $this->load();

foreach ($this->userOptions as $userOption) {
            /* @var UserOption $userOption */
            if ($userOption->option == $option)
                return $userOption;
        }

$this->getLog()->debug('UserOption %s not found', $option);

throw new NotFoundException('User Option not found');
    }

/**
     * Remove the provided option
     * @param \Xibo\Entity\UserOption $option
     * @return $this
     */
    private function removeOption($option)
    {
        $this->getLog()->debug('Removing: ' . $option);

$this->userOptionsRemoved[] = $option;
        $this->userOptions = array_diff($this->userOptions, [$option]);
        return $this;
    }

/**
     * Get User Option Value
     * @param string $option
     * @param mixed $default
     * @return mixed
     */
    public function getOptionValue($option, $default)
    {
        $this->load();

try {
            $userOption = $this->getOption($option);
            return $userOption->value;
        } catch (NotFoundException $e) {
            return $default;
        }
    }

/**
     * Set User Option Value
     * @param string $option
     * @param mixed $value
     */
    public function setOptionValue($option, $value)
    {
        try {
            $option = $this->getOption($option);

if ($value === null) {
                $this->removeOption($option);
            } else {
                $option->value = $value;
            }
        } catch (NotFoundException $e) {
            $this->userOptions[] = $this->userOptionFactory->create($this->userId, $option, $value);
        }
    }

/**
     * Set a new password
     * @param string $password
     * @param string[Optional] $oldPassword
     */
    public function setNewPassword($password, $oldPassword = null)
    {
        // Validate the old password if one is provided
        if ($oldPassword != null) {
            $this->checkPassword($oldPassword);
        }

// Test against a policy if one exists
        $this->testPasswordAgainstPolicy($password);

// Set the hash
        $this->setNewPasswordHash($password);
    }

/**
     * Set a new password and hash
     * @param string $password
     */
    private function setNewPasswordHash($password)
    {
        $this->password = password_hash($password, PASSWORD_DEFAULT);
        $this->CSPRNG = 2;
    }

/**
     * Check password
     * @param string $password
     * @throws NotFoundException if the user has not been loaded
     * @throws AccessDeniedException if the passwords don't match
     */
    public function checkPassword($password)
    {
        if ($this->userId == 0)
            throw new NotFoundException(__('User not found'));

if ($this->CSPRNG == 0) {
            // Password is tested using a plain MD5 check
            if ($this->password != md5($password))
                throw new AccessDeniedException();
        }
        else if ($this->CSPRNG == 1) {
            // Test with Pbkdf2
            try {
                if (!Pbkdf2Hash::verifyPassword($password, $this->password)) {
                    $this->getLog()->debug('Password failed Pbkdf2Hash Check.');
                    throw new AccessDeniedException();
                }
            } catch (\InvalidArgumentException $e) {
                $this->getLog()->warning('Invalid password hash stored for userId ' . $this->userId);
                $this->getLog()->debug('Hash error: ' . $e->getMessage());
            }
        }
        else {
            if (!password_verify($password, $this->password)) {
                $this->getLog()->debug('Password failed Hash Check.');
                throw new AccessDeniedException();
            }
        }

$this->getLog()->debug('Password checked out OK');

// Do we need to convert?
        $this->updateHashIfRequired($password);
    }

/**
     * Update hash if required
     * @param string $password
     */
    private function updateHashIfRequired($password)
    {
        if (($this->CSPRNG == 0 || $this->CSPRNG == 1) || ($this->CSPRNG == 2 && password_needs_rehash($this->password, PASSWORD_DEFAULT))) {
            $this->getLog()->debug('Converting password to use latest hash');

// Set the hash
            $this->setNewPasswordHash($password);

// Save
            $this->save(['validate' => false, 'passwordUpdate' => true]);
        }
    }

/**
     * Check to see if a user id is in the session information
     * @return bool
     */
    public function hasIdentity()
    {
        $userId = isset($_SESSION['userid']) ? intval($_SESSION['userid']) : 0;

// Checks for a user ID in the session variable
        if ($userId == 0) {
            unset($_SESSION['userid']);
            return false;
        }
        else {
            $this->userId = $userId;
            return true;
        }
    }

/**
     * Load this User
     * @param bool $all Load everything this user owns
     * @throws NotFoundException
     */
    public function load($all = false)
    {
        if ($this->userId == null || $this->loaded)
            return;

if ($this->userGroupFactory == null)
            throw new \RuntimeException('Cannot load user without first calling setUserGroupFactory');

$this->getLog()->debug('Loading %d. All Objects = %d', $this->userId, $all);

$this->groups = $this->userGroupFactory->getByUserId($this->userId);

if ($all) {
            if ($this->campaignFactory == null || $this->layoutFactory == null || $this->mediaFactory == null || $this->scheduleFactory == null || $this->playlistFactory == null)
                throw new \RuntimeException('Cannot load user with all objects without first calling setChildObjectDependencies');

$this->campaigns = $this->campaignFactory->getByOwnerId($this->userId);
            $this->layouts = $this->layoutFactory->getByOwnerId($this->userId);
            $this->media = $this->mediaFactory->getByOwnerId($this->userId);
            $this->events = $this->scheduleFactory->getByOwnerId($this->userId);
            $this->playlists = $this->playlistFactory->getByOwnerId($this->userId);
        }

$this->userOptions = $this->userOptionFactory->getByUserId($this->userId);

// Set the hash
        $this->hash = $this->hash();

$this->loaded = true;
    }

/**
     * Does this User have any children
     * @return int
     */
    public function countChildren()
    {
        $this->load(true);

$count = count($this->campaigns) + count($this->layouts) + count($this->media) + count($this->events) + count($this->playlists);
        $this->getLog()->debug('Counted Children on %d, there are %d', $this->userId, $count);

return $count;
    }

/**
     * Reassign all
     * @param User $user
     * @throws XiboException
     */
    public function reassignAllTo($user)
    {
        $this->getLog()->debug('Reassign all to %s', $user->userName);

$this->load(true);

$this->getLog()->debug('There are %d children', $this->countChildren());

// Go through each item and reassign the owner to the provided user.
        foreach ($this->media as $media) {
            /* @var Media $media */
            $media->setOwner($user->getOwnerId());
            $media->save();
        }
        foreach ($this->events as $event) {
            /* @var Schedule $event */
            $event->load();
            $event->setOwner($user->getOwnerId());
            $event->setDisplayFactory($this->displayFactory);
            $event->load();
            $event->save(['generate' => false]);
        }
        foreach ($this->layouts as $layout) {
            /* @var Layout $layout */
            $layout->setOwner($user->getOwnerId(), true);
            $layout->save(['saveTags' => false]);
        }
        foreach ($this->campaigns as $campaign) {
            /* @var Campaign $campaign */
            $campaign->setOwner($user->getOwnerId());
            $campaign->save(['saveTags' => false]);
        }
        foreach ($this->playlists as $playlist) {
            $playlist->setOwner($user->getOwnerId());
            $playlist->save(['saveTags' => false]);
        }
        foreach($this->displayGroupFactory->getByOwnerId($this->userId) as $displayGroup) {
            $displayGroup->setOwner($user->getOwnerId());
            $displayGroup->save(['saveTags' => false, 'manageDynamicDisplayLinks' => false]);
        }
        foreach($this->dataSetFactory->getByOwnerId($this->userId) as $dataSet) {
            $dataSet->setOwner($user->getOwnerId());
            $dataSet->save();
        }

// Reassign resolutions
        $this->getStore()->update('UPDATE `resolution` SET userId = :userId WHERE userId = :oldUserId', [
            'userId' => $user->userId,
            'oldUserId' => $this->userId
        ]);

// Reassign Dayparts
        $this->getStore()->update('UPDATE `daypart` SET userId = :userId WHERE userId = :oldUserId', [
            'userId' => $user->userId,
            'oldUserId' => $this->userId
        ]);

// Load again
        $this->loaded = false;
        $this->load(true);

$this->getLog()->debug('Reassign and reload complete, there are %d children', $this->countChildren());
    }

/**
     * Validate
     * @throws XiboException
     */
    public function validate()
    {
        if (!v::alnum('_.-')->length(1, 50)->validate($this->userName) && !v::email()->validate($this->userName))
            throw new InvalidArgumentException(__('User name must be between 1 and 50 characters.'), 'userName');

if (!v::stringType()->notEmpty()->validate($this->password))
            throw new InvalidArgumentException(__('Please enter a Password.'), 'password');

if (!v::intType()->validate($this->libraryQuota))
            throw new InvalidArgumentException(__('Library Quota must be a whole number.'), 'libraryQuota');

if (!empty($this->email) && !v::email()->validate($this->email))
            throw new InvalidArgumentException(__('Please enter a valid email address or leave it empty.'), 'email');

try {
            $user = $this->userFactory->getByName($this->userName);

if ($this->userId == null || $this->userId != $user->userId)
                throw new DuplicateEntityException(__('There is already a user with this name. Please choose another.'));
        }
        catch (NotFoundException $e) {

}

try {
            $this->pageFactory->getById($this->homePageId);
        }
        catch (NotFoundException $e) {
            throw new InvalidArgumentException(__('Selected home page does not exist'), 'homePageId');
        }

// Library quota
        if (!empty($this->libraryQuota) && $this->libraryQuota < 0) {
            throw new InvalidArgumentException(__('Library Quota must be a positive number.'), 'libraryQuota');
        }
    }

/**
     * Save User
     * @param array $options
     * @throws \Xibo\Exception\XiboException
     */
    public function save($options = [])
    {
        $options = array_merge([
            'validate' => true,
            'passwordUpdate' => false,
            'saveUserOptions' => true
        ], $options);

if ($options['validate'])
            $this->validate();

$this->getLog()->debug('Saving user. %s', $this);

if ($this->userId == 0)
            $this->add();
        else if ($options['passwordUpdate'])
            $this->updatePassword();
        else if ($this->hash() != $this->hash)
            $this->update();

// Save user options
        if ($options['saveUserOptions']) {
            // Remove any that have been cleared
            foreach ($this->userOptionsRemoved as $userOption) {
                $userOption->delete();
            }

// Save all Options
            foreach ($this->userOptions as $userOption) {
                /* @var UserOption $userOption */
                $userOption->userId = $this->userId;
                $userOption->save();
            }
        }
    }

/**
     * Delete User
     * @throws InvalidArgumentException
     * @throws NotFoundException
     * @throws XiboException
     */
    public function delete()
    {
        $this->getLog()->debug('Deleting %d', $this->userId);

// We must ensure everything is loaded before we delete
        if ($this->hash == null)
            $this->load(true);

// Remove the user specific group
        $group = $this->userGroupFactory->getById($this->groupId);
        $group->delete();

// Delete all user options
        foreach ($this->userOptions as $userOption) {
            /* @var RegionOption $userOption */
            $userOption->delete();
        }

// Remove any assignments to groups
        foreach ($this->groups as $group) {
            /* @var UserGroup $group */
            $group->unassignUser($this);
            $group->save(['validate' => false]);
        }

// Delete any layouts
        foreach ($this->layouts as $layout) {
            /* @var Layout $layout */
            $layout->delete();
        }

// Delete any Campaigns
        foreach ($this->campaigns as $campaign) {
            /* @var Campaign $campaign */
            $campaign->setChildObjectDependencies($this->layoutFactory);
            $campaign->delete();
        }

// Delete any scheduled events
        foreach ($this->events as $event) {
            /* @var Schedule $event */
            $event->delete();
        }

// Delete any media
        foreach ($this->media as $media) {
            /* @var Media $media */
            $media->setChildObjectDependencies($this->layoutFactory, $this->widgetFactory, $this->displayGroupFactory, $this->displayFactory, $this->scheduleFactory, $this->playerVersionFactory);
            $media->delete();
        }

// Delete Playlists owned by this user
        foreach ($this->playlists as $playlist) {
            /* @var Playlist $playlist */
            $playlist->delete();
        }

// Display Groups owned by this user
        foreach($this->displayGroupFactory->getByOwnerId($this->userId) as $displayGroup) {
            $displayGroup->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);
            $displayGroup->delete();
        }

foreach($this->dataSetFactory->getByOwnerId($this->userId) as $dataSet) {
            $dataSet->delete();
        }

// Delete user specific entities
        $this->getStore()->update('DELETE FROM `resolution` WHERE userId = :userId', ['userId' => $this->userId]);
        $this->getStore()->update('DELETE FROM `daypart` WHERE userId = :userId', ['userId' => $this->userId]);
        $this->getStore()->update('DELETE FROM `session` WHERE userId = :userId', ['userId' => $this->userId]);
        $this->getStore()->update('DELETE FROM `user` WHERE userId = :userId', ['userId' => $this->userId]);
    }

/**
     * Add user
     */
    private function add()
    {
        $sql = 'INSERT INTO `user` (UserName, UserPassword, isPasswordChangeRequired, usertypeid, newUserWizard, email, homePageId, CSPRNG, firstName, lastName, phone, ref1, ref2, ref3, ref4, ref5)
                     VALUES (:userName, :password, :isPasswordChangeRequired, :userTypeId, :newUserWizard, :email, :homePageId, :CSPRNG, :firstName, :lastName, :phone, :ref1, :ref2, :ref3, :ref4, :ref5)';

// Get the ID of the record we just inserted
        $this->userId = $this->getStore()->insert($sql, [
            'userName' => $this->userName,
            'password' => $this->password,
            'isPasswordChangeRequired' => $this->isPasswordChangeRequired,
            'userTypeId' => $this->userTypeId,
            'newUserWizard' => $this->newUserWizard,
            'email' => $this->email,
            'homePageId' => $this->homePageId,
            'CSPRNG' => $this->CSPRNG,
            'firstName' => $this->firstName,
            'lastName' => $this->lastName,
            'phone' => $this->phone,
            'ref1' => $this->ref1,
            'ref2' => $this->ref2,
            'ref3' => $this->ref3,
            'ref4' => $this->ref4,
            'ref5' => $this->ref5
        ]);

// Add the user group
        /* @var UserGroup $group */
        $group = $this->userGroupFactory->create($this->userName, $this->libraryQuota);
        $group->setOwner($this);
        $group->isSystemNotification = $this->isSystemNotification;
        $group->isDisplayNotification = $this->isDisplayNotification;
        $group->save();
    }

/**
     * Update user
     */
    private function update()
    {
        $this->getLog()->debug('Update userId %d.', $this->userId);

$sql = 'UPDATE `user` SET UserName = :userName,
                  homePageId = :homePageId,
                  Email = :email,
                  Retired = :retired,
                  userTypeId = :userTypeId,
                  newUserWizard = :newUserWizard,
                  CSPRNG = :CSPRNG,
                  `UserPassword` = :password,
                  `isPasswordChangeRequired` = :isPasswordChangeRequired,
                  `twoFactorTypeId` = :twoFactorTypeId,
                  `twoFactorSecret` = :twoFactorSecret,
                  `twoFactorRecoveryCodes` = :twoFactorRecoveryCodes,
                  `showContentFrom` = :showContentFrom,
                  `firstName` = :firstName,
                  `lastName` = :lastName,
                  `phone` = :phone,
                  `ref1` = :ref1,
                  `ref2` = :ref2,
                  `ref3` = :ref3,
                  `ref4` = :ref4,
                  `ref5` = :ref5
               WHERE userId = :userId';

$params = array(
            'userName' => $this->userName,
            'userTypeId' => $this->userTypeId,
            'email' => $this->email,
            'homePageId' => $this->homePageId,
            'retired' => $this->retired,
            'newUserWizard' => $this->newUserWizard,
            'CSPRNG' => $this->CSPRNG,
            'password' => $this->password,
            'isPasswordChangeRequired' => $this->isPasswordChangeRequired,
            'twoFactorTypeId' => $this->twoFactorTypeId,
            'twoFactorSecret' => $this->twoFactorSecret,
            'twoFactorRecoveryCodes' => ($this->twoFactorRecoveryCodes == '') ? null : json_encode($this->twoFactorRecoveryCodes),
            'showContentFrom' => $this->showContentFrom,
            'firstName' => $this->firstName,
            'lastName' => $this->lastName,
            'phone' => $this->phone,
            'ref1' => $this->ref1,
            'ref2' => $this->ref2,
            'ref3' => $this->ref3,
            'ref4' => $this->ref4,
            'ref5' => $this->ref5,
            'userId' => $this->userId
        );

$this->getStore()->update($sql, $params);

// Update the group
        // This is essentially a dirty edit (i.e. we don't touch the group assignments)
        $group = $this->userGroupFactory->getById($this->groupId);
        $group->group = $this->userName;
        $group->libraryQuota = $this->libraryQuota;
        $group->isSystemNotification = $this->isSystemNotification;
        $group->isDisplayNotification = $this->isDisplayNotification;
        $group->save(['linkUsers' => false]);
    }

/**
     * Update user
     */
    private function updatePassword()
    {
        $this->getLog()->debug('Update user password. %d', $this->userId);

$sql = 'UPDATE `user` SET CSPRNG = :CSPRNG,
                  `UserPassword` = :password
               WHERE userId = :userId';

$params = array(
            'CSPRNG' => $this->CSPRNG,
            'password' => $this->password,
            'userId' => $this->userId
        );

$this->getStore()->update($sql, $params);
    }

/**
     * Update the Last Accessed date
     * @param bool $forcePasswordChange
     */
    public function touch($forcePasswordChange = false)
    {
        $sql = 'UPDATE `user` SET lastAccessed = :time ';

if ($forcePasswordChange) {
            $sql .= ' , isPasswordChangeRequired = 1 ';
        }

$sql .= ' WHERE userId = :userId';

// This needs to happen on a separate connection
        $this->getStore()->update($sql, [
            'userId' => $this->userId,
            'time' => date("Y-m-d H:i:s")
        ]);
    }

/**
     * Authenticates the route given against the user credentials held
     * @param $route string
     * @param $method string
     * @param $scopes array[ScopeEntity]
     * @throws \Xibo\Exception\ConfigurationException
     * @throws \Xibo\Exception\NotFoundException
     */
    public function routeAuthentication($route, $method = null, $scopes = null)
    {
        // Scopes provided?
        if ($scopes !== null && is_array($scopes)) {
            //$this->getLog()->debug('Scopes: %s', json_encode($scopes));
            foreach ($scopes as $scope) {
                /** @var ScopeEntity $scope */

// Valid routes
                if ($scope->getId() != 'all') {
                    $this->getLog()->debug('Test authentication for route %s %s against scope %s', $method, $route, $scope->getId());

// Check the route and request method
                    $this->applicationScopeFactory->getById($scope->getId())->checkRoute($method, $route);
                }
            }
        }

// Check route
        if (!$this->routeViewable($route)) {
            $this->getLog()->debug('Blocked assess to unrecognised page: ' . $route . '.');
            throw new AccessDeniedException();
        }
    }

/**
     * Authenticates the route given against the user credentials held
     * @param $route string
     * @return bool
     * @throws ConfigurationException
     */
    public function routeViewable($route)
    {
        if ($this->pageFactory == null)
            throw new ConfigurationException('routeViewable called before user object has been initialised');

// Super-admins and DOOH users get all routes
        if ($this->isSuperAdmin())
            return true;

// All users have access to the logout page
        if ($route === '/logout')
            return true;

try {
            if ($this->pagePermissionCache == null) {
                // Load all viewable pages into the permissions cache
                $this->pagePermissionCache = $this->pageFactory->query();
            }
        }
        catch (\PDOException $e) {
            $this->getLog()->info('SQL Error getting permissions: %s', $e->getMessage());

return false;
        }

// Home route
        if ($route === '/')
            return true;

$route = explode('/', ltrim($route, '/'));

// See if our route is in the page permission cache
        foreach ($this->pagePermissionCache as $page) {
            /* @var Page $page */
            if ($page->name == $route[0])
                return true;
        }

$this->getLog()->debug('Route %s not viewable', $route[0]);
        return false;
    }

/**
     * Given an array of routes, count the ones that are viewable
     * @param $routes
     * @return int
     * @throws \Xibo\Exception\ConfigurationException
     */
    public function countViewable($routes)
    {
        // Shortcut for super admins.
        if ($this->isSuperAdmin()) {
            return count($routes);
        }

// Test each route
        $count = 0;

foreach ($routes as $route) {
            if ($this->routeViewable($route)) {
                $count++;
            }
        }

return $count;
    }

/**
     * Load permissions for a particular entity
     * @param string $entity
     * @return array[Permission]
     */
    private function loadPermissions($entity)
    {
        // Check our cache to see if we have permissions for this entity cached already
        if (!isset($this->permissionCache[$entity])) {

// Store the results in the cache (default to empty result)
            $this->permissionCache[$entity] = array();

// Turn it into a ID keyed array
            foreach ($this->permissionFactory->getByUserId($entity, $this->userId) as $permission) {
                /* @var \Xibo\Entity\Permission $permission */
                // Always take the max
                if (array_key_exists($permission->objectId, $this->permissionCache[$entity])) {
                    $old = $this->permissionCache[$entity][$permission->objectId];
                    // Create a new permission record with the max of current and new
                    $new = $this->permissionFactory->createEmpty();
                    $new->view = max($permission->view, $old->view);
                    $new->edit = max($permission->edit, $old->edit);
                    $new->delete = max($permission->delete, $old->delete);

$this->permissionCache[$entity][$permission->objectId] = $new;
                }
                else
                    $this->permissionCache[$entity][$permission->objectId] = $permission;
            }
        }

return $this->permissionCache[$entity];
    }

/**
     * Check that this object can be used with the permissions sytem
     * @param object $object
     */
    private function checkObjectCompatibility($object)
    {
        if (!method_exists($object, 'getId') || !method_exists($object, 'getOwnerId') || !method_exists($object, 'permissionsClass'))
            throw new \InvalidArgumentException(__('Provided Object not under permission management'));
    }

/**
     * Get a permission object
     * @param object $object
     * @return \Xibo\Entity\Permission
     */
    public function getPermission($object)
    {
        // Check that this object has the necessary methods
        $this->checkObjectCompatibility($object);

// Admin users
        if ($this->isSuperAdmin() || $this->userId == $object->getOwnerId()) {
            return $this->permissionFactory->getFullPermissions();
        }

// Group Admins
        if ($this->userTypeId == 2 && count(array_intersect($this->groups, $this->userGroupFactory->getByUserId($object->getOwnerId()))))
            // Group Admin and in the same group as the owner.
            return $this->permissionFactory->getFullPermissions();

// Get the permissions for that entity
        $permissions = $this->loadPermissions($object->permissionsClass());

// Check to see if our object is in the list
        if (array_key_exists($object->getId(), $permissions))
            return $permissions[$object->getId()];
        else
            return $this->permissionFactory->createEmpty();
    }

/**
     * Check the given object is viewable
     * @param object $object
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function checkViewable($object)
    {
        // Check that this object has the necessary methods
        $this->checkObjectCompatibility($object);

// Admin users
        if ($this->isSuperAdmin() || $this->userId == $object->getOwnerId())
            return true;

// Get the permissions for that entity
        $permissions = $this->loadPermissions($object->permissionsClass());

// Check to see if our object is in the list
        if (array_key_exists($object->getId(), $permissions))
            return ($permissions[$object->getId()]->view == 1);
        else
            return false;
    }

/**
     * Check the given object is editable
     * @param object $object
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function checkEditable($object)
    {
        // Check that this object has the necessary methods
        $this->checkObjectCompatibility($object);

// Admin users
        if ($this->isSuperAdmin() || $this->userId == $object->getOwnerId())
            return true;

// Get the permissions for that entity
        $permissions = $this->loadPermissions($object->permissionsClass());

// Check to see if our object is in the list
        if (array_key_exists($object->getId(), $permissions))
            return ($permissions[$object->getId()]->edit == 1);
        else
            return false;
    }

/**
     * Check the given object is delete-able
     * @param object $object
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function checkDeleteable($object)
    {
        // Check that this object has the necessary methods
        $this->checkObjectCompatibility($object);

// Admin users
        // Note here that the DOOH user isn't allowed to outright delete other users things
        if ($this->userTypeId == 1 || $this->userId == $object->getOwnerId())
            return true;

// Get the permissions for that entity
        $permissions = $this->loadPermissions($object->permissionsClass());

// Check to see if our object is in the list
        if (array_key_exists($object->getId(), $permissions))
            return ($permissions[$object->getId()]->delete == 1);
        else
            return false;
    }

/**
     * Check the given objects permissions are modify-able
     * @param object $object
     * @return bool
     * @throws \Xibo\Exception\NotFoundException
     */
    public function checkPermissionsModifyable($object)
    {
        // Check that this object has the necessary methods
        $this->checkObjectCompatibility($object);

// Admin users
        // Note here that the DOOH user isn't allowed to outright change permissions on  other users things
        if ($this->userTypeId == 1 || $this->userId == $object->getOwnerId())
            return true;
        // Group Admins
        else if ($this->userTypeId == 2 && count(array_intersect($this->groups, $this->userGroupFactory->getByUserId($object->getOwnerId()))))
            // Group Admin and in the same group as the owner.
            return true;
        else
            return false;
    }

/**
     * Returns the usertypeid for this user object.
     * @return int
     */
    public function getUserTypeId()
    {
        return $this->userTypeId;
    }

/**
     * Is a super admin
     * @return bool
     */
    public function isSuperAdmin()
    {
        return ($this->userTypeId == 1 || $this->userTypeId == 4);
    }

/**
     * Is Group Admin
     * @return bool
     */
    public function isGroupAdmin()
    {
       return ($this->userTypeId == 2);
    }

/**
     * Is this users library quota full
     * @param boolean $reconnect
     * @throws LibraryFullException when the library is full or cannot be determined
     */
    public function isQuotaFullByUser($reconnect = false)
    {
        $groupId = 0;
        $userQuota = 0;

// Get the maximum quota of this users groups and their own quota
        $rows = $this->getStore()->select('
            SELECT group.groupId, IFNULL(group.libraryQuota, 0) AS libraryQuota
              FROM `group`
                INNER JOIN `lkusergroup`
                ON group.groupId = lkusergroup.groupId
             WHERE lkusergroup.userId = :userId
            ORDER BY `group`.isUserSpecific DESC, IFNULL(group.libraryQuota, 0) DESC
        ', ['userId' => $this->userId], null, $reconnect);

if (count($rows) <= 0) {
            throw new LibraryFullException('Problem calculating this users library quota.');
        }

foreach ($rows as $row) {

if ($row['libraryQuota'] > 0) {
                $groupId = $row['groupId'];
                $userQuota = intval($row['libraryQuota']);
                break;
            }
        }

if ($userQuota > 0) {
            // If there is a quota, then test it against the current library position for this user.
            //   use the groupId that generated the quota in order to calculate the usage
            $rows = $this->getStore()->select('
              SELECT IFNULL(SUM(FileSize), 0) AS SumSize
                FROM `media`
                  INNER JOIN `lkusergroup`
                  ON lkusergroup.userId = media.userId
               WHERE lkusergroup.groupId = :groupId
            ', ['groupId' => $groupId], null, true);

if (count($rows) <= 0) {
                throw new LibraryFullException("Error Processing Request", 1);
            }

$fileSize = intval($rows[0]['SumSize']);

if (($fileSize / 1024) >= $userQuota) {
                $this->getLog()->debug('User has exceeded library quota. FileSize: ' . $fileSize . ' bytes, quota is ' . $userQuota * 1024);
                throw new LibraryFullException(__('You have exceeded your library quota'));
            }
        }
    }

/**
     * Tests the supplied password against the password policy
     * @param string $password
     */
    public function testPasswordAgainstPolicy($password)
    {
        // Check password complexity
        $policy = $this->configService->getSetting('USER_PASSWORD_POLICY');

if ($policy != '')
        {
            $policyError = $this->configService->getSetting('USER_PASSWORD_ERROR');
            $policyError = ($policyError == '') ? __('Your password does not meet the required complexity') : $policyError;

if(!preg_match($policy, $password, $matches))
                throw new \InvalidArgumentException($policyError);
        }
    }

/**
     * @return UserOption[]
     */
    public function getUserOptions()
    {
        // Don't return anything with Grid in it (these have to be specifically requested).
        return array_filter($this->userOptions, function($element) {
            return !(stripos($element->option, 'Grid'));
        });
    }

/**
     * Clear the two factor stored secret and recovery codes
     */
    public function clearTwoFactor()
    {
        $this->twoFactorTypeId = 0;
        $this->twoFactorSecret = NULL;
        $this->twoFactorRecoveryCodes = NULL;

$sql = 'UPDATE `user` SET twoFactorSecret = :twoFactorSecret,
                  twoFactorTypeId = :twoFactorTypeId,
                  twoFactorRecoveryCodes =:twoFactorRecoveryCodes
               WHERE userId = :userId';

$params = [
            'userId' => $this->userId,
            'twoFactorSecret' => $this->twoFactorSecret,
            'twoFactorTypeId' => $this->twoFactorTypeId,
            'twoFactorRecoveryCodes' => $this->twoFactorRecoveryCodes
        ];

$this->getStore()->update($sql, $params);
    }

public function updateRecoveryCodes($recoveryCodes)
    {
        $sql = 'UPDATE `user` SET twoFactorRecoveryCodes = :twoFactorRecoveryCodes WHERE userId = :userId';

$params = [
            'userId' => $this->userId,
            'twoFactorRecoveryCodes' => $recoveryCodes
        ];

$this->getStore()->update($sql, $params);
    }
}
PK�������qYq�ē������
��Module.phpnu��[�����������<?php
/*
 * Xibo - Digital Signage - http://www.xibo.org.uk
 * Copyright (C) 2015 Spring Signage Ltd
 *
 * This file (Module.php) is part of Xibo.
 *
 * Xibo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Xibo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Xibo.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Xibo\Entity;

use Respect\Validation\Validator as v;
use Xibo\Exception\InvalidArgumentException;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;

/**
 * Class Module
 * @package Xibo\Entity
 *
 * @SWG\Definition()
 */
class Module implements \JsonSerializable
{
    use EntityTrait;

/**
     * @SWG\Property(description="The ID of this Module")
     * @var int
     */
    public $moduleId;

/**
     * @SWG\Property(description="Module Name")
     * @var string
     */
    public $name;

/**
     * @SWG\Property(description="Description of the Module")
     * @var string
     */
    public $description;

/**
     * @SWG\Property(description="A comma separated list of Valid Extensions")
     * @var string
     */
    public $validExtensions;

/**
     * @SWG\Property(description="The type code for this module")
     * @var string
     */
    public $type;

/**
     * @SWG\Property(description="A flag indicating whether this module is enabled")
     * @var int
     */
    public $enabled;

/**
     * @SWG\Property(description="A flag indicating whether this module is specific to a Layout or can be uploaded to the Library")
     * @var int
     */
    public $regionSpecific;

/**
     * @SWG\Property(description="A flag indicating whether the Layout designer should render a preview of this module")
     * @var int
     */
    public $previewEnabled;

/**
     * @SWG\Property(description="A flag indicating whether the module is assignable to a Layout")
     * @var int
     */
    public $assignable;

/**
     * @SWG\Property(description="A flag indicating whether the module should be rendered natively by the Player or via the CMS (native|html)")
     * @var string
     */
    public $renderAs;

/**
     * @SWG\Property(description="The default duration for Widgets of this Module when the user has elected to not set a specific duration.")
     * @var int
     */
    public $defaultDuration;

/**
     * @SWG\Property(description="An array of additional module specific settings")
     * @var string[]
     */
    public $settings = [];

/**
     * @SWG\Property(description="The schema version of the module")
     * @var int
     */
    public $schemaVersion;

/**
     * @SWG\Property(description="Class Name including namespace")
     * @var string
     */
    public $class;

/**
     * @SWG\Property(description="The Twig View path for module specific templates")
     * @var string
     */
    public $viewPath = '../modules';

/**
     * @SWG\Property(description="The original installation name of this module.")
     * @var string
     */
    public $installName;

/**
     * @return string
     */
    public function __toString()
    {
        return sprintf('%s - %s', $this->type, $this->name);
    }

public function validate()
    {
        if (!v::intType()->validate($this->defaultDuration))
            throw new InvalidArgumentException(__('Default Duration is a required field.'), 'defaultDuration');

if (!empty($this->validExtensions) && !v::alnum(',')->validate($this->validExtensions)) {
            throw new InvalidArgumentException(__('Comma separated file extensions only please, without the .'), 'validExtensions');
        }
    }

public function save()
    {
        $this->validate();

if ($this->moduleId == null || $this->moduleId == 0)
            $this->add();
        else
            $this->edit();

}

private function add()
    {
        $this->moduleId = $this->getStore()->insert('
          INSERT INTO `module` (`Module`, `Name`, `Enabled`, `RegionSpecific`, `Description`, `SchemaVersion`, `ValidExtensions`, `PreviewEnabled`, `assignable`, `render_as`, `settings`, `viewPath`, `class`, `defaultDuration`, `installName`)
            VALUES (:module, :name, :enabled, :region_specific, :description,
                :schema_version, :valid_extensions, :preview_enabled, :assignable, :render_as, :settings, :viewPath, :class, :defaultDuration, :installName)
        ', [
            'module' => $this->type,
            'name' => $this->name,
            'enabled' => $this->enabled,
            'region_specific' => $this->regionSpecific,
            'description' => $this->description,
            'schema_version' => $this->schemaVersion,
            'valid_extensions' => $this->validExtensions,
            'preview_enabled' => $this->previewEnabled,
            'assignable' => $this->assignable,
            'render_as' => $this->renderAs,
            'settings' => json_encode($this->settings),
            'viewPath' => $this->viewPath,
            'class' => $this->class,
            'defaultDuration' => $this->defaultDuration,
            'installName' => $this->installName
        ]);
    }

private function edit()
    {
        $this->getStore()->update('
          UPDATE `module` SET
              enabled = :enabled,
              previewEnabled = :previewEnabled,
              validExtensions = :validExtensions,
              defaultDuration = :defaultDuration,
              settings = :settings
           WHERE moduleid = :moduleId
        ', [
            'moduleId' => $this->moduleId,
            'enabled' => $this->enabled,
            'previewEnabled' => $this->previewEnabled,
            'validExtensions' => $this->validExtensions,
            'defaultDuration' => $this->defaultDuration,
            'settings' => json_encode($this->settings)
        ]);
    }
}PK���������qYwV�'����
����������������Layout.phpnu��[�����������PK���������qYS��T6%��6%��
��������������UserGroup.phpnu��[�����������PK���������qYi3.������������������KB�Resolution.phpnu��[�����������PK���������qY�MD8�5���5��������������JX�DataSetColumn.phpnu��[�����������PK���������qYI5\������������������s��UserType.phpnu��[�����������PK���������qYi�t��������������������Setting.phpnu��[�����������PK���������qY�����|���|��
��������������Widget.phpnu��[�����������PK���������qY�j� �� ����������������EntityTrait.phpnu��[�����������PK���������qY*�h�������
������������*0�Bandwidth.phpnu��[�����������PK���������qYᗄ�@���@���������������;7�Playlist.phpnu��[�����������PK���������qYrMa����������������������Session.phpnu��[�����������PK���������qY�%|��|��	������������}��Media.phpnu��[�����������PK���������qY�?	;�#���#���������������D�Application.phpnu��[�����������PK���������qY�"��L���L����������������h�Schedule.phpnu��[�����������PK���������qY���xU	��U	��������������=�RegionOption.phpnu��[�����������PK���������qY��y�L��L���������������F�PlayerVersion.phpnu��[�����������PK���������qY|kPh������������������8Z�DataSetColumnType.phpnu��[�����������PK���������qY���Ag��g��������������^�ScheduleEvent.phpnu��[�����������PK���������qY��&�z2��z2���������������`�Notification.phpnu��[�����������PK���������qY�_������������������p��DataSetRss.phpnu��[�����������PK���������qY����������������������a��Transition.phpnu��[�����������PK���������qY��ۋ��������������������d��Display.phpnu��[�����������PK���������qY�na0�������������������:�AuditLog.phpnu��[�����������PK���������qY�������������������C�SavedReport.phpnu��[�����������PK���������qY��Iv*)��*)��������������Y�DayPart.phpnu��[�����������PK���������qY�h��]��]��������������j��WidgetOption.phpnu��[�����������PK���������qYo��-��������������������ApplicationScope.phpnu��[�����������PK���������qY��YX�	���	��������������=��RequiredFile.phpnu��[�����������PK���������qY����,��,����������������DisplayEvent.phpnu��[�����������PK���������qYe&|��F���F�����������������Campaign.phpnu��[�����������PK���������qYY���?��?��
���������������Region.phpnu��[�����������PK���������qY�a+Db��Db���������������+�Tag.phpnu��[�����������PK���������qY�m��N��N��������������O��Task.phpnu��[�����������PK���������qY��`��	���	��������������ը�UserOption.phpnu��[�����������PK���������qYuW!��!��������������ڲ�Command.phpnu��[�����������PK���������qY�;{�M��M��������������6��LogEntry.phpnu��[�����������PK���������qYi{ᷳj���j�����������������DisplayProfile.phpnu��[�����������PK���������qY�Mc%�����������������;�WidgetAudio.phpnu��[�����������PK���������qYZ�օ-~��-~���������������C�DisplayGroup.phpnu��[�����������PK���������qY:(u�����������������a��Page.phpnu��[�����������PK���������qY��Dp<���<������������������DataSet.phpnu��[�����������PK���������qY�f�Z��Z��������������O�ApplicationRedirectUri.phpnu��[�����������PK���������qY�I��	���	���������������V�ScheduleExclusion.phpnu��[�����������PK���������qY5���S��S���������������`�DataType.phpnu��[�����������PK���������qY�q|������������������7d�Permission.phpnu��[�����������PK���������qYK�˵������������������`z�ReportSchedule.phpnu��[�����������PK���������qY&?R������������������_��UserNotification.phpnu��[�����������PK���������qY{��������������������O��Help.phpnu��[�����������PK���������qYl�Q������������������X��ScheduleReminder.phpnu��[�����������PK���������qY�z
xλ��λ�����������������User.phpnu��[�����������PK���������qYq�ē������
�������������{	�Module.phpnu��[�����������PK����3�3����X�	���