OTS-OpenSource/Cloud-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
Cloud-CMS/lib/Xmds/Soap.php

3139 lines
128 KiB
PHP
Raw Permalink Normal View History

Initial Upload
2025-12-02 10:32:59 -05:00
<?php
/*
* Copyright (C) 2025 Xibo Signage Ltd
*
* Xibo - Digital Signage - https://xibosignage.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\Xmds;
use Carbon\Carbon;
use Monolog\Logger;
use Stash\Interfaces\PoolInterface;
use Stash\Invalidation;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Xibo\Entity\Bandwidth;
use Xibo\Entity\Display;
use Xibo\Entity\Region;
use Xibo\Entity\RequiredFile;
use Xibo\Entity\Schedule;
use Xibo\Event\DataConnectorScriptRequestEvent;
use Xibo\Event\XmdsDependencyListEvent;
use Xibo\Factory\BandwidthFactory;
use Xibo\Factory\DataSetFactory;
use Xibo\Factory\DayPartFactory;
use Xibo\Factory\DisplayEventFactory;
use Xibo\Factory\DisplayFactory;
use Xibo\Factory\LayoutFactory;
use Xibo\Factory\MediaFactory;
use Xibo\Factory\ModuleFactory;
use Xibo\Factory\NotificationFactory;
use Xibo\Factory\PlayerFaultFactory;
use Xibo\Factory\PlayerVersionFactory;
use Xibo\Factory\RegionFactory;
use Xibo\Factory\RequiredFileFactory;
use Xibo\Factory\ScheduleFactory;
use Xibo\Factory\SyncGroupFactory;
use Xibo\Factory\UserFactory;
use Xibo\Factory\UserGroupFactory;
use Xibo\Factory\WidgetFactory;
use Xibo\Helper\ByteFormatter;
use Xibo\Helper\DateFormatHelper;
use Xibo\Helper\LinkSigner;
use Xibo\Helper\SanitizerService;
use Xibo\Helper\Status;
use Xibo\Service\ConfigServiceInterface;
use Xibo\Service\LogServiceInterface;
use Xibo\Storage\StorageServiceInterface;
use Xibo\Storage\TimeSeriesStoreInterface;
use Xibo\Support\Exception\ControllerNotImplemented;
use Xibo\Support\Exception\DeadlockException;
use Xibo\Support\Exception\GeneralException;
use Xibo\Support\Exception\NotFoundException;
use Xibo\Xmds\Entity\Dependency;
use Xibo\Xmds\Listeners\XmdsDataConnectorListener;
/**
* Class Soap
* @package Xibo\Xmds
*/
class Soap
{
/**
* @var Display
*/
protected $display;
/** @var Carbon */
protected $fromFilter;
/** @var Carbon */
protected $toFilter;
/** @var Carbon */
protected $localFromFilter;
/** @var Carbon */
protected $localToFilter;
/**
* @var LogProcessor
*/
protected $logProcessor;
/** @var PoolInterface */
protected $pool;
/** @var StorageServiceInterface */
private $store;
/** @var TimeSeriesStoreInterface */
private $timeSeriesStore;
/** @var LogServiceInterface */
private $logService;
/** @var SanitizerService */
private $sanitizerService;
/** @var ConfigServiceInterface */
protected $configService;
/** @var RequiredFileFactory */
protected $requiredFileFactory;
/** @var ModuleFactory */
protected $moduleFactory;
/** @var LayoutFactory */
protected $layoutFactory;
/** @var DataSetFactory */
protected $dataSetFactory;
/** @var DisplayFactory */
protected $displayFactory;
/** @var UserGroupFactory */
protected $userGroupFactory;
/** @var BandwidthFactory */
protected $bandwidthFactory;
/** @var MediaFactory */
protected $mediaFactory;
/** @var WidgetFactory */
protected $widgetFactory;
/** @var RegionFactory */
protected $regionFactory;
/** @var NotificationFactory */
protected $notificationFactory;
/** @var DisplayEventFactory */
protected $displayEventFactory;
/** @var ScheduleFactory */
protected $scheduleFactory;
/** @var DayPartFactory */
protected $dayPartFactory;
/** @var PlayerVersionFactory */
protected $playerVersionFactory;
/** @var \Xibo\Factory\SyncGroupFactory */
protected $syncGroupFactory;
/**
* @var EventDispatcher
*/
private $dispatcher;
/** @var \Xibo\Factory\CampaignFactory */
private $campaignFactory;
/** @var PlayerFaultFactory */
protected $playerFaultFactory;
/**
* Soap constructor.
* @param LogProcessor $logProcessor
* @param PoolInterface $pool
* @param StorageServiceInterface $store
* @param TimeSeriesStoreInterface $timeSeriesStore
* @param LogServiceInterface $log
* @param SanitizerService $sanitizer
* @param ConfigServiceInterface $config
* @param RequiredFileFactory $requiredFileFactory
* @param ModuleFactory $moduleFactory
* @param LayoutFactory $layoutFactory
* @param DataSetFactory $dataSetFactory
* @param DisplayFactory $displayFactory
* @param UserFactory $userGroupFactory
* @param BandwidthFactory $bandwidthFactory
* @param MediaFactory $mediaFactory
* @param WidgetFactory $widgetFactory
* @param RegionFactory $regionFactory
* @param NotificationFactory $notificationFactory
* @param DisplayEventFactory $displayEventFactory
* @param ScheduleFactory $scheduleFactory
* @param DayPartFactory $dayPartFactory
* @param PlayerVersionFactory $playerVersionFactory
* @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher
* @param \Xibo\Factory\CampaignFactory $campaignFactory
* @param SyncGroupFactory $syncGroupFactory
*/
public function __construct(
$logProcessor,
$pool,
$store,
$timeSeriesStore,
$log,
$sanitizer,
$config,
$requiredFileFactory,
$moduleFactory,
$layoutFactory,
$dataSetFactory,
$displayFactory,
$userGroupFactory,
$bandwidthFactory,
$mediaFactory,
$widgetFactory,
$regionFactory,
$notificationFactory,
$displayEventFactory,
$scheduleFactory,
$dayPartFactory,
$playerVersionFactory,
$dispatcher,
$campaignFactory,
$syncGroupFactory,
$playerFaultFactory
) {
$this->logProcessor = $logProcessor;
$this->pool = $pool;
$this->store = $store;
$this->timeSeriesStore = $timeSeriesStore;
$this->logService = $log;
$this->sanitizerService = $sanitizer;
$this->configService = $config;
$this->requiredFileFactory = $requiredFileFactory;
$this->moduleFactory = $moduleFactory;
$this->layoutFactory = $layoutFactory;
$this->dataSetFactory = $dataSetFactory;
$this->displayFactory = $displayFactory;
$this->userGroupFactory = $userGroupFactory;
$this->bandwidthFactory = $bandwidthFactory;
$this->mediaFactory = $mediaFactory;
$this->widgetFactory = $widgetFactory;
$this->regionFactory = $regionFactory;
$this->notificationFactory = $notificationFactory;
$this->displayEventFactory = $displayEventFactory;
$this->scheduleFactory = $scheduleFactory;
$this->dayPartFactory = $dayPartFactory;
$this->playerVersionFactory = $playerVersionFactory;
$this->dispatcher = $dispatcher;
$this->campaignFactory = $campaignFactory;
$this->syncGroupFactory = $syncGroupFactory;
$this->playerFaultFactory = $playerFaultFactory;
}
/**
* Get Cache Pool
* @return \Stash\Interfaces\PoolInterface
*/
protected function getPool()
{
return $this->pool;
}
/**
* Get Store
* @return StorageServiceInterface
*/
protected function getStore()
{
return $this->store;
}
/**
* Get Time Series Store
* @return TimeSeriesStoreInterface
*/
protected function getTimeSeriesStore()
{
return $this->timeSeriesStore;
}
/**
* Get Log
* @return LogServiceInterface
*/
protected function getLog()
{
return $this->logService;
}
/**
* @param $array
* @return \Xibo\Support\Sanitizer\SanitizerInterface
*/
protected function getSanitizer($array)
{
return $this->sanitizerService->getSanitizer($array);
}
/**
* Get Config
* @return ConfigServiceInterface
*/
protected function getConfig()
{
return $this->configService;
}
/**
* @return EventDispatcher
*/
public function getDispatcher(): EventDispatcher
{
if ($this->dispatcher === null) {
$this->getLog()->error('getDispatcher: [soap] No dispatcher found, returning an empty one');
$this->dispatcher = new EventDispatcher();
}
return $this->dispatcher;
}
/**
* Get Required Files (common)
* @param $serverKey
* @param $hardwareKey
* @param bool $httpDownloads
* @param bool $isSupportsDataUrl Does the callee support data URLs in widgets?
* @param bool $isSupportsDependency Does the callee support a separate dependency call?
* @return string
* @throws \DOMException
* @throws \SoapFault
* @throws \Xibo\Support\Exception\NotFoundException
*/
protected function doRequiredFiles(
$serverKey,
$hardwareKey,
bool $httpDownloads,
bool $isSupportsDataUrl = false,
bool $isSupportsDependency = false
) {
$this->logProcessor->setRoute('RequiredFiles');
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey
]);
// Sanitize
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
$libraryLocation = $this->getConfig()->getSetting('LIBRARY_LOCATION');
// auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Sender', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
// Check the cache
$cache = $this->getPool()->getItem($this->display->getCacheKey() . '/requiredFiles');
$cache->setInvalidationMethod(Invalidation::OLD);
$output = $cache->get();
// Required files are cached for 4 hours
if ($cache->isHit()) {
$this->getLog()->info('Returning required files from Cache for display ' . $this->display->display);
// Resign HTTP links and extend expiry
$document = new \DOMDocument('1.0');
$document->loadXML($output);
$cdnUrl = $this->configService->getSetting('CDN_URL');
foreach ($document->documentElement->childNodes as $node) {
if ($node instanceof \DOMElement) {
if ($node->getAttribute('download') === 'http') {
$type = match ($node->getAttribute('type')) {
'layout' => 'L',
'media' => 'M',
default => 'P',
};
// HTTP download for a v3 player will have saved the type and fileType as M and media
// respectively, which is different to what we use in the URL.
$assetType = $node->getAttribute('assetType');
if (!empty($assetType)) {
$type = 'P';
$fileType = $assetType;
} else {
$fileType = $node->getAttribute('fileType');
}
// Use the realId if we have it.
$realId = $node->getAttribute('realId');
if (empty($realId)) {
$realId = $node->getAttribute('id');
}
// Generate a new URL.
$newUrl = LinkSigner::generateSignedLink(
$this->display,
$this->configService->getApiKeyDetails()['encryptionKey'],
$cdnUrl,
$type,
$realId,
$node->getAttribute('saveAs'),
$fileType,
);
$node->setAttribute('path', $newUrl);
}
}
}
$output = $document->saveXML();
// Log Bandwidth
$this->logBandwidth($this->display->displayId, Bandwidth::$RF, strlen($output));
return $output;
}
// We need to regenerate
// Lock the cache
$cache->lock(120);
// Get all required files for this display.
// we will use this to drop items from the requirefile table if they are no longer in required files
$rfIds = array_map(function ($element) {
return intval($element['rfId']);
}, $this->getStore()->select('SELECT rfId FROM `requiredfile` WHERE displayId = :displayId', [
'displayId' => $this->display->displayId
]));
$newRfIds = [];
// Build a new RF
$requiredFilesXml = new \DOMDocument('1.0');
$fileElements = $requiredFilesXml->createElement('files');
$requiredFilesXml->appendChild($fileElements);
// Filter criteria
$this->setDateFilters();
// Add the filter dates to the RF xml document
$fileElements->setAttribute('generated', Carbon::now()->format(DateFormatHelper::getSystemFormat()));
$fileElements->setAttribute('fitlerFrom', $this->fromFilter->format(DateFormatHelper::getSystemFormat()));
$fileElements->setAttribute('fitlerTo', $this->toFilter->format(DateFormatHelper::getSystemFormat()));
// Player dependencies
// -------------------
// Output player dependencies such as the player bundle, fonts, etc.
// 1) get a list of dependencies.
$dependencyListEvent = new XmdsDependencyListEvent($this->display);
$this->getDispatcher()->dispatch($dependencyListEvent, 'xmds.dependency.list');
// 2) Each dependency returned needs to be added to RF.
foreach ($dependencyListEvent->getDependencies() as $dependency) {
// Add a new required file for this.
$this->addDependency(
$newRfIds,
$requiredFilesXml,
$fileElements,
$httpDownloads,
$isSupportsDependency,
$dependency
);
}
// ------------
// Dependencies finished
// Default Layout
$defaultLayoutId = ($this->display->defaultLayoutId === null || $this->display->defaultLayoutId === 0)
? $this->getConfig()->getSetting('DEFAULT_LAYOUT')
: $this->display->defaultLayoutId;
// Get a list of all layout ids in the schedule right now
// including any layouts that have been associated to our Display Group
try {
$dbh = $this->getStore()->getConnection();
$SQL = '
SELECT DISTINCT `lklayoutdisplaygroup`.layoutId
FROM `lklayoutdisplaygroup`
INNER JOIN `lkdgdg`
ON `lkdgdg`.parentId = `lklayoutdisplaygroup`.displayGroupId
INNER JOIN `lkdisplaydg`
ON lkdisplaydg.DisplayGroupID = `lkdgdg`.childId
INNER JOIN `layout`
ON `layout`.layoutID = `lklayoutdisplaygroup`.layoutId
WHERE lkdisplaydg.DisplayID = :displayId
ORDER BY layoutId
';
$params = [
'displayId' => $this->display->displayId
];
$this->getLog()->sql($SQL, $params);
$sth = $dbh->prepare($SQL);
$sth->execute($params);
// Build a list of Layouts
$layouts = [];
// Our layout list will always include the default layout
if ($defaultLayoutId != null) {
$layouts[] = $defaultLayoutId;
}
// Build up the other layouts into an array
foreach ($sth->fetchAll() as $row) {
$parsedRow = $this->getSanitizer($row);
$layouts[] = $parsedRow->getInt('layoutId');
}
// Also look at the schedule
foreach ($this->scheduleFactory->getForXmds(
$this->display->displayId,
$this->fromFilter,
$this->toFilter
) as $row) {
$parsedRow = $this->getSanitizer($row);
$schedule = $this->scheduleFactory->createEmpty()->hydrate($row);
// Is this scheduled event a synchronised timezone?
// if it is, then we get our events with respect to the timezone of the display
$isSyncTimezone = ($schedule->syncTimezone == 1 && !empty($this->display->timeZone));
try {
if ($isSyncTimezone) {
$scheduleEvents = $schedule->getEvents($this->localFromFilter, $this->localToFilter);
} else {
$scheduleEvents = $schedule->getEvents($this->fromFilter, $this->toFilter);
}
} catch (GeneralException $e) {
$this->getLog()->error('Unable to getEvents for ' . $schedule->eventId);
continue;
}
if (count($scheduleEvents) <= 0) {
continue;
}
$this->getLog()->debug(count($scheduleEvents) . ' events for eventId ' . $schedule->eventId);
// Sync events
$layoutId = ($schedule->eventTypeId == Schedule::$SYNC_EVENT)
? $parsedRow->getInt('syncLayoutId')
: $parsedRow->getInt('layoutId');
// Layout codes (action events)
$layoutCode = $parsedRow->getString('actionLayoutCode');
if ($layoutId != null &&
(
$schedule->eventTypeId == Schedule::$LAYOUT_EVENT ||
$schedule->eventTypeId == Schedule::$OVERLAY_EVENT ||
$schedule->eventTypeId == Schedule::$INTERRUPT_EVENT ||
$schedule->eventTypeId == Schedule::$CAMPAIGN_EVENT ||
$schedule->eventTypeId == Schedule::$MEDIA_EVENT ||
$schedule->eventTypeId == Schedule::$PLAYLIST_EVENT ||
$schedule->eventTypeId == Schedule::$SYNC_EVENT
)
) {
$layouts[] = $layoutId;
}
if (!empty($layoutCode) && $schedule->eventTypeId == Schedule::$ACTION_EVENT) {
$actionEventLayout = $this->layoutFactory->getByCode($layoutCode);
if ($actionEventLayout->status <= 3) {
$layouts[] = $actionEventLayout->layoutId;
} else {
$this->getLog()->error(sprintf(__('Scheduled Action Event ID %d contains an invalid Layout linked to it by the Layout code.'), $schedule->eventId));
}
}
// Data Connectors
if ($isSupportsDependency && $schedule->eventTypeId === Schedule::$DATA_CONNECTOR_EVENT) {
$dataSet = $this->dataSetFactory->getById($row['dataSetId']);
if ($dataSet->dataConnectorSource != 'user_defined') {
// Dispatch an event to save the data connector javascript from the connector
$dataConnectorScriptRequestEvent = new DataConnectorScriptRequestEvent($dataSet);
$this->getDispatcher()
->dispatch($dataConnectorScriptRequestEvent, DataConnectorScriptRequestEvent::$NAME);
}
$this->addDependency(
$newRfIds,
$requiredFilesXml,
$fileElements,
$httpDownloads,
$isSupportsDependency,
XmdsDataConnectorListener::getDataConnectorDependency($libraryLocation, $row['dataSetId']),
);
}
}
} catch (\Exception $e) {
$this->getLog()->error('Unable to get a list of layouts. ' . $e->getMessage());
return new \SoapFault('Sender', 'Unable to get a list of layouts');
}
// workout if any of the layouts we have in our list has Actions pointing to another Layout.
$actionLayoutIds = [];
$processedLayoutIds = [];
foreach ($layouts as $layoutId) {
// this is recursive function, as we need to get 2nd level nesting and beyond
$this->layoutFactory->getActionPublishedLayoutIds($layoutId, $actionLayoutIds, $processedLayoutIds);
}
// merge the Action layouts to our array, we need the player to download all resources on them
if (!empty($actionLayoutIds)) {
$layouts = array_unique(array_merge($layouts, $actionLayoutIds));
}
// Create a comma separated list to pass into the query which gets file nodes
$layoutIdList = implode(',', $layouts);
try {
$dbh = $this->getStore()->getConnection();
// Run a query to get all required files for this display.
// Include the following:
// DownloadOrder:
// 1 - Media Linked to Displays
// 2 - Media Linked to Widgets in the Scheduled Layouts (linked through Playlists)
// 3 - Background Images for all Scheduled Layouts
// 4 - Media linked to display profile (linked through PlayerSoftware)
$SQL = "
SELECT 1 AS DownloadOrder,
`media`.storedAs AS path,
`media`.mediaID AS id,
`media`.`MD5`,
`media`.FileSize,
`media`.released
FROM `media`
INNER JOIN `display_media`
ON `display_media`.mediaid = `media`.mediaId
WHERE `display_media`.displayId = :displayId
UNION ALL
SELECT 2 AS DownloadOrder,
`media`.storedAs AS path,
`media`.mediaID AS id,
`media`.`MD5`,
`media`.FileSize,
`media`.released
FROM `media`
INNER JOIN `lkmediadisplaygroup`
ON lkmediadisplaygroup.mediaid = media.MediaID
INNER JOIN `lkdgdg`
ON `lkdgdg`.parentId = `lkmediadisplaygroup`.displayGroupId
INNER JOIN `lkdisplaydg`
ON lkdisplaydg.DisplayGroupID = `lkdgdg`.childId
WHERE lkdisplaydg.DisplayID = :displayId
UNION ALL
SELECT 3 AS DownloadOrder,
`media`.storedAs AS path,
`media`.mediaID AS id,
`media`.`MD5`,
`media`.FileSize,
`media`.released
FROM region
INNER JOIN playlist
ON playlist.regionId = region.regionId
INNER JOIN lkplaylistplaylist
ON lkplaylistplaylist.parentId = playlist.playlistId
INNER JOIN widget
ON widget.playlistId = lkplaylistplaylist.childId
INNER JOIN lkwidgetmedia
ON widget.widgetId = lkwidgetmedia.widgetId
INNER JOIN media
ON media.mediaId = lkwidgetmedia.mediaId
WHERE region.layoutId IN (%s)
UNION ALL
SELECT 4 AS DownloadOrder,
`media`.storedAs AS path,
`media`.mediaId AS id,
`media`.`MD5`,
`media`.FileSize,
`media`.released
FROM `media`
WHERE `media`.mediaID IN (
SELECT backgroundImageId
FROM `layout`
WHERE layoutId IN (%s)
)
";
$params = ['displayId' => $this->display->displayId];
$SQL .= ' ORDER BY DownloadOrder ';
// Sub layoutId list
$SQL = sprintf($SQL, $layoutIdList, $layoutIdList);
$this->getLog()->sql($SQL, $params);
$sth = $dbh->prepare($SQL);
$sth->execute($params);
// Prepare a SQL statement in case we need to update the MD5 and FileSize on media nodes.
$mediaSth = $dbh->prepare('UPDATE media SET `MD5` = :md5, FileSize = :size WHERE MediaID = :mediaid');
// Keep a list of path names added to RF to prevent duplicates
$pathsAdded = [];
$cdnUrl = $this->configService->getSetting('CDN_URL');
foreach ($sth->fetchAll() as $row) {
$parsedRow = $this->getSanitizer($row);
// Media
$path = $parsedRow->getString('path');
$id = $parsedRow->getParam('id');
$md5 = $row['MD5'];
$fileSize = $parsedRow->getInt('FileSize');
$released = $parsedRow->getInt('released');
// Check we haven't added this before
if (in_array($path, $pathsAdded)) {
continue;
}
// Do we need to calculate a new MD5?
// If they are empty calculate them and save them back to the media.
if ($md5 == '' || $fileSize == 0) {
$md5 = md5_file($libraryLocation . $path);
$fileSize = filesize($libraryLocation . $path);
// Update the media record with this information
$mediaSth->execute(['md5' => $md5, 'size' => $fileSize, 'mediaid' => $id]);
}
// Add nonce
$mediaNonce = $this->requiredFileFactory
->createForMedia($this->display->displayId, $id, $fileSize, $path, $released)
->save();
// skip media which has released == 0 or 2
if ($released == 0 || $released == 2) {
continue;
}
$newRfIds[] = $mediaNonce->rfId;
// Add the file node
$file = $requiredFilesXml->createElement('file');
$file->setAttribute('type', 'media');
$file->setAttribute('id', $id);
$file->setAttribute('size', $fileSize);
$file->setAttribute('md5', $md5);
if ($httpDownloads) {
// Serve a link instead (standard HTTP link)
$file->setAttribute('path', LinkSigner::generateSignedLink(
$this->display,
$this->configService->getApiKeyDetails()['encryptionKey'],
$cdnUrl,
'M',
$id,
$path,
));
$file->setAttribute('saveAs', $path);
$file->setAttribute('download', 'http');
} else {
$file->setAttribute('download', 'xmds');
$file->setAttribute('path', $path);
}
$fileElements->appendChild($file);
// Add to paths added
$pathsAdded[] = $path;
}
} catch (\Exception $e) {
$this->getLog()->error('Unable to get a list of required files. ' . $e->getMessage());
$this->getLog()->debug($e->getTraceAsString());
return new \SoapFault('Sender', 'Unable to get a list of files');
}
// Get an array of modules to use
$modules = $this->moduleFactory->getKeyedArrayOfModules();
// Reset the paths added array to start again with layouts
$pathsAdded = [];
$cdnUrl = $this->configService->getSetting('CDN_URL');
// Go through each layout and see if we need to supply any resource nodes.
foreach ($layouts as $layoutId) {
try {
// Check we haven't added this before
if (in_array($layoutId, $pathsAdded)) {
continue;
}
// Load this layout
$layout = $this->layoutFactory->concurrentRequestLock($this->layoutFactory->loadById($layoutId));
try {
$layout->loadPlaylists();
// Make sure its XLF is up-to-date
$path = $layout->xlfToDisk(['notify' => false]);
} finally {
$this->layoutFactory->concurrentRequestRelease($layout);
}
// If the status is *still* 4, then we skip this layout as it cannot build
if ($layout->status === Status::$STATUS_INVALID) {
$this->getLog()->debug('Skipping layoutId ' . $layout->layoutId . ' which wont build');
continue;
}
// For layouts the MD5 column is the layout xml
$fileSize = filesize($path);
$md5 = md5_file($path);
$fileName = basename($path);
// Log
$this->getLog()->debug('MD5 for layoutid ' . $layoutId . ' is: [' . $md5 . ']');
// Add nonce
$layoutNonce = $this->requiredFileFactory
->createForLayout($this->display->displayId, $layoutId, $fileSize, $fileName)
->save();
$newRfIds[] = $layoutNonce->rfId;
// Add the Layout file element
$file = $requiredFilesXml->createElement('file');
$file->setAttribute('type', 'layout');
$file->setAttribute('id', $layoutId);
$file->setAttribute('size', $fileSize);
$file->setAttribute('md5', $md5);
// add Layout code only if code identifier is set on the Layout.
if ($layout->code != null) {
$file->setAttribute('code', $layout->code);
}
// Permissive check for http layouts - always allow unless windows and <= 120
$supportsHttpLayouts = !($this->display->clientType == 'windows' && $this->display->clientCode <= 120);
if ($httpDownloads && $supportsHttpLayouts) {
// Serve a link instead (standard HTTP link)
$file->setAttribute('path', LinkSigner::generateSignedLink(
$this->display,
$this->configService->getApiKeyDetails()['encryptionKey'],
$cdnUrl,
'L',
$layoutId,
$fileName,
));
$file->setAttribute('saveAs', $fileName);
$file->setAttribute('download', 'http');
} else {
$file->setAttribute('download', 'xmds');
$file->setAttribute('path', $layoutId);
}
// Get the Layout Modified Date
// To cover for instances where modifiedDt isn't correctly recorded
// use the createdDt instead.
$layoutModifiedDt = Carbon::createFromFormat(
DateFormatHelper::getSystemFormat(),
$layout->modifiedDt ?? $layout->createdDt
);
// merge regions and drawers
/** @var Region[] $allRegions */
$allRegions = array_merge($layout->regions, $layout->drawers);
// Load the layout XML and work out if we have any ticker / text / dataset media items
// Append layout resources before layout, so they are downloaded first.
// If layouts are set to expire immediately, the new layout will use the old resources if
// the layout is downloaded first.
foreach ($allRegions as $region) {
$playlist = $region->getPlaylist();
$playlist->setModuleFactory($this->moduleFactory);
// Playlists might mean we include a widget more than once per region
// if so, we only want to download a single copy of its resource node
// if it is included in 2 regions - we most likely want a copy for each
$resourcesAdded = [];
foreach ($playlist->expandWidgets() as $widget) {
if (!array_key_exists($widget->type, $modules)) {
$this->getLog()->debug('Unknown type of widget: ' . $widget->type);
continue;
}
// Any global widgets, html based widgets or region specific widgets
if ($widget->type === 'global'
|| $modules[$widget->type]->renderAs === 'html'
|| $modules[$widget->type]->regionSpecific == 1
) {
// If we've already parsed this widget in this region, then don't bother doing it again
// we will only generate the same details.
if (in_array($widget->widgetId, $resourcesAdded)) {
continue;
}
// We've added this widget already
$resourcesAdded[] = $widget->widgetId;
// Get the widget modified date
// we will use the latter of this vs the layout modified date as the updated attribute
// on required files
$widgetModifiedDt = Carbon::createFromTimestamp($widget->modifiedDt);
// Updated date is the greatest of layout/widget modified date
$updatedDt = ($layoutModifiedDt->greaterThan($widgetModifiedDt))
? $layoutModifiedDt
: $widgetModifiedDt;
// If this is a canvas region, then only send the data, unless we're the global
// widget
$isShouldSendHtml = $region->type !== 'canvas' || $widget->type === 'global';
if ($isShouldSendHtml) {
// Add the resource node to the XML for this widfget.
$getResourceRf = $this->requiredFileFactory
->createForGetResource($this->display->displayId, $widget->widgetId)
->save();
$newRfIds[] = $getResourceRf->rfId;
// Append this item to required files
$resourceFile = $requiredFilesXml->createElement('file');
$resourceFile->setAttribute('type', 'resource');
$resourceFile->setAttribute('id', $widget->widgetId);
$resourceFile->setAttribute('layoutid', $layoutId);
$resourceFile->setAttribute('regionid', $region->regionId);
$resourceFile->setAttribute('mediaid', $widget->widgetId);
}
// Get the module
$dataModule = $modules[$widget->type];
// Does this also have an associated data file?
// we add this for < XMDS v7 as well, because the record is used by the widget sync task
// the player shouldn't receive it.
if ($dataModule->isDataProviderExpected()) {
// A node specifically for the widget data.
if ($isSupportsDataUrl) {
// Newer player (v4 onward), add widget node for returning data
$dataFile = $requiredFilesXml->createElement('file');
$dataFile->setAttribute('type', 'widget');
$dataFile->setAttribute('id', $widget->widgetId);
$dataFile->setAttribute(
'updateInterval',
$widget->getOptionValue(
'updateInterval',
$dataModule->getPropertyDefault('updateInterval') ?? 120,
)
);
$fileElements->appendChild($dataFile);
} else if ($isShouldSendHtml) {
// Older player, needs to change the updated date on the resource node
// Has our widget been updated recently?
// TODO: Does this need to be the most recent updated date for all the widgets in
// this region?
$dataProvider = $dataModule->createDataProvider($widget);
$dataProvider->setDisplayProperties(
$this->display->latitude ?: $this->getConfig()->getSetting('DEFAULT_LAT'),
$this->display->longitude ?: $this->getConfig()->getSetting('DEFAULT_LONG'),
$this->display->displayId
);
try {
$widgetDataProviderCache = $this->moduleFactory
->createWidgetDataProviderCache();
$cacheKey = $this->moduleFactory->determineCacheKey(
$dataModule,
$widget,
$this->display->displayId,
$dataProvider,
$dataModule->getWidgetProviderOrNull()
);
// We do not pass a modifiedDt in here because we always expect to be cached
$cacheDt = $widgetDataProviderCache->getCacheDate($dataProvider, $cacheKey);
if ($cacheDt !== null) {
$updatedDt = ($cacheDt->greaterThan($updatedDt))
? $cacheDt
: $updatedDt;
}
} catch (\Exception) {
$this->getLog()->error(
'doRequiredFiles: Failed to get data cache modified date for widgetId '
. $widget->widgetId
);
}
}
// Used by WidgetSync to understand when to keep the cache warm
$getDataRf = $this->requiredFileFactory
->createForGetData($this->display->displayId, $widget->widgetId)
->save();
$newRfIds[] = $getDataRf->rfId;
}
if ($isShouldSendHtml) {
// Append our resource node.
$resourceFile->setAttribute('updated', $updatedDt->format('U'));
$fileElements->appendChild($resourceFile);
}
}
// Add any assets from this widget/template (unless assetId already added)
if (!in_array('module_' . $widget->type, $resourcesAdded)) {
foreach ($modules[$widget->type]->getAssets() as $asset) {
// Do not send assets if they are CMS only
if (!$asset->isSendToPlayer()) {
continue;
}
$asset->updateAssetCache($libraryLocation);
// Add a new required file for this.
try {
$this->addDependency(
$newRfIds,
$requiredFilesXml,
$fileElements,
$httpDownloads,
$isSupportsDependency,
$asset->getDependency()
);
} catch (\Exception $exception) {
$this->getLog()->error('Invalid asset: ' . $exception->getMessage());
}
}
$resourcesAdded[] = 'module_' . $widget->type;
}
// Templates (there should only be one)
if ($modules[$widget->type]->isTemplateExpected()) {
$templateId = $widget->getOptionValue('templateId', null);
if ($templateId !== null && !in_array('template_' . $templateId, $resourcesAdded)) {
// Get this template and its assets
$templates = $this->widgetFactory->getTemplatesForWidgets(
$modules[$widget->type],
[$widget]
);
foreach ($templates as $template) {
foreach ($template->getAssets() as $asset) {
// Do not send assets if they are CMS only
if (!$asset->isSendToPlayer()) {
continue;
}
$asset->updateAssetCache($libraryLocation);
// Add a new required file for this.
try {
$this->addDependency(
$newRfIds,
$requiredFilesXml,
$fileElements,
$httpDownloads,
$isSupportsDependency,
$asset->getDependency()
);
} catch (\Exception $exception) {
$this->getLog()->error('Invalid asset: ' . $exception->getMessage());
}
}
}
$resourcesAdded[] = 'template_' . $templateId;
}
}
}
}
// Append Layout
$fileElements->appendChild($file);
// Add to paths added
$pathsAdded[] = $layoutId;
} catch (NotFoundException) {
$this->getLog()->error('Layout not found - ID: ' . $layoutId . ', skipping');
continue;
} catch (GeneralException $e) {
$this->getLog()->error('Cannot generate layout - ID: ' . $layoutId
. ', skipping, e = ' . $e->getMessage());
continue;
}
}
// Add Purge List node
$purgeList = $requiredFilesXml->createElement('purge');
$fileElements->appendChild($purgeList);
try {
$dbh = $this->getStore()->getConnection();
// get list of mediaId/storedAs that should be purged from the Player storage
// records in that table older than provided expiryDate, should be removed by the task
$sth = $dbh->prepare('SELECT mediaId, storedAs FROM purge_list');
$sth->execute();
// Add a purge list item for each file
foreach ($sth->fetchAll() as $row) {
$item = $requiredFilesXml->createElement('item');
$item->setAttribute('id', $row['mediaId']);
$item->setAttribute('storedAs', $row['storedAs']);
$purgeList->appendChild($item);
}
} catch (\Exception $e) {
$this->getLog()->error('Unable to get a list of purge_list files. ' . $e->getMessage());
return new \SoapFault('Sender', 'Unable to get purge list files');
}
$this->getLog()->debug($requiredFilesXml->saveXML());
// Return the results of requiredFiles()
$requiredFilesXml->formatOutput = true;
$output = $requiredFilesXml->saveXML();
// Cache
$cache->set($output);
// RF cache expires every 4 hours
$cache->expiresAfter(3600*4);
$this->getPool()->saveDeferred($cache);
// Remove any required files that remain in the array of rfIds
$rfIds = array_values(array_diff($rfIds, $newRfIds));
if (count($rfIds) > 0) {
$this->getLog()->debug('Removing ' . count($rfIds) . ' from requiredfiles');
try {
// Execute this on the default connection
$this->getStore()->updateWithDeadlockLoop(
'DELETE FROM `requiredfile` WHERE rfId IN ('
. implode(',', array_fill(0, count($rfIds), '?')) . ')',
$rfIds
);
} catch (DeadlockException $deadlockException) {
$this->getLog()->error('Deadlock when deleting required files - ignoring and continuing with request');
}
}
// Set any remaining required files to have 0 bytes requested (as we've generated a new nonce)
$this->getStore()->update('
UPDATE `requiredfile`
SET `bytesRequested` = 0
WHERE `displayId` = :displayId
AND `type` NOT IN (\'W\', \'D\')
', [
'displayId' => $this->display->displayId
]);
// Log Bandwidth
$this->logBandwidth($this->display->displayId, Bandwidth::$RF, strlen($output));
return $output;
}
/**
* @param $serverKey
* @param $hardwareKey
* @param array $options
* @return mixed
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doSchedule($serverKey, $hardwareKey, $options = [])
{
$this->logProcessor->setRoute('Schedule');
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey
]);
$options = array_merge(['dependentsAsNodes' => false, 'includeOverlays' => false], $options);
// Sanitize
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
// auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Sender', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
// Check the cache
$cache = $this->getPool()->getItem($this->display->getCacheKey() . '/schedule');
$cache->setInvalidationMethod(Invalidation::OLD);
$output = $cache->get();
if ($cache->isHit()) {
$this->getLog()->info(sprintf(
'Returning Schedule from Cache for display %s. Options %s.',
$this->display->display,
json_encode($options)
));
// Log Bandwidth
$this->logBandwidth($this->display->displayId, Bandwidth::$SCHEDULE, strlen($output));
return $output;
}
// We need to regenerate
// Lock the cache
$cache->lock(120);
// Generate the Schedule XML
$scheduleXml = new \DOMDocument('1.0');
$layoutElements = $scheduleXml->createElement('schedule');
$scheduleXml->appendChild($layoutElements);
// Filter criteria
$this->setDateFilters();
// Add the filter dates to the RF xml document
$layoutElements->setAttribute('generated', Carbon::now()->format(DateFormatHelper::getSystemFormat()));
$layoutElements->setAttribute('filterFrom', $this->fromFilter->format(DateFormatHelper::getSystemFormat()));
$layoutElements->setAttribute('filterTo', $this->toFilter->format(DateFormatHelper::getSystemFormat()));
// Default Layout
$defaultLayoutId = ($this->display->defaultLayoutId === null || $this->display->defaultLayoutId === 0)
? intval($this->getConfig()->getSetting('DEFAULT_LAYOUT', 0))
: $this->display->defaultLayoutId;
try {
// Dependencies
// ------------
$moduleDependents = [];
$dependencyListEvent = new XmdsDependencyListEvent($this->display);
$this->getDispatcher()->dispatch($dependencyListEvent, 'xmds.dependency.list');
// Add each resolved dependency to our list of global dependents.
foreach ($dependencyListEvent->getDependencies() as $dependency) {
$moduleDependents[] = basename($dependency->path);
}
// Add file nodes to the $fileElements
// Firstly get all the scheduled layouts
$events = $this->scheduleFactory->getForXmds(
$this->display->displayId,
$this->fromFilter,
$this->toFilter,
$options
);
// If our dependents are nodes, then build a list of layouts we can use to query for nodes
$layoutDependents = [];
// Layouts
$layoutIds = [];
// Add the default layout if it isn't empty.
if ($defaultLayoutId !== 0) {
$layoutIds[] = $defaultLayoutId;
}
// Preparse events
foreach ($events as $event) {
$layoutId = ($event['eventTypeId'] == Schedule::$SYNC_EVENT) ? $event['syncLayoutId'] : $event['layoutId'];
if (!empty($layoutId) && !in_array($layoutId, $layoutIds)) {
$layoutIds[] = $layoutId;
}
}
$SQL = '
SELECT DISTINCT `region`.layoutId, `media`.storedAs
FROM region
INNER JOIN playlist
ON playlist.regionId = region.regionId
INNER JOIN lkplaylistplaylist
ON lkplaylistplaylist.parentId = playlist.playlistId
INNER JOIN widget
ON widget.playlistId = lkplaylistplaylist.childId
INNER JOIN lkwidgetmedia
ON widget.widgetId = lkwidgetmedia.widgetId
INNER JOIN media
ON media.mediaId = lkwidgetmedia.mediaId
WHERE region.layoutId IN (' . implode(',', $layoutIds) . ')
AND media.type <> \'module\'
';
foreach ($this->getStore()->select($SQL, []) as $row) {
if (!array_key_exists($row['layoutId'], $layoutDependents))
$layoutDependents[$row['layoutId']] = [];
$layoutDependents[$row['layoutId']][] = $row['storedAs'];
}
$this->getLog()->debug(sprintf('Resolved dependents for Schedule: %s.', json_encode($layoutDependents, JSON_PRETTY_PRINT)));
// Additional nodes.
$overlayNodes = null;
$actionNodes = null;
$dataConnectorNodes = null;
// We must have some results in here by this point
foreach ($events as $row) {
$parsedRow = $this->getSanitizer($row);
$schedule = $this->scheduleFactory->createEmpty()->hydrate($row);
// Is this scheduled event a synchronised timezone?
// if it is, then we get our events with respect to the timezone of the display
$isSyncTimezone = ($schedule->syncTimezone == 1 && !empty($this->display->timeZone));
try {
if ($isSyncTimezone) {
$scheduleEvents = $schedule->getEvents($this->localFromFilter, $this->localToFilter);
} else {
$scheduleEvents = $schedule->getEvents($this->fromFilter, $this->toFilter);
}
} catch (GeneralException $e) {
$this->getLog()->error('Unable to getEvents for ' . $schedule->eventId);
continue;
}
$this->getLog()->debug(count($scheduleEvents) . ' events for eventId ' . $schedule->eventId);
// Load the whole schedule object if we have some events attached
if (count($scheduleEvents) > 0) {
$schedule->load(['loadDisplayGroups' => false]);
}
foreach ($scheduleEvents as $scheduleEvent) {
$eventTypeId = $row['eventTypeId'];
if ($row['eventTypeId'] == Schedule::$SYNC_EVENT) {
$layoutId = $row['syncLayoutId'];
$status = intval($row['syncLayoutStatus']);
$duration = $row['syncLayoutDuration'];
} else {
$layoutId = $row['layoutId'];
$status = intval($row['status']);
$duration = $row['duration'];
}
$commandCode = $row['code'];
// Handle the from/to date of the events we have been returned (they are all returned with respect to
// the current CMS timezone)
// Does the Display have a timezone?
if ($isSyncTimezone) {
$fromDt = Carbon::createFromTimestamp($scheduleEvent->fromDt, $this->display->timeZone)->format(DateFormatHelper::getSystemFormat());
$toDt = Carbon::createFromTimestamp($scheduleEvent->toDt, $this->display->timeZone)->format(DateFormatHelper::getSystemFormat());
} else {
$fromDt = Carbon::createFromTimestamp($scheduleEvent->fromDt)->format(DateFormatHelper::getSystemFormat());
$toDt = Carbon::createFromTimestamp($scheduleEvent->toDt)->format(DateFormatHelper::getSystemFormat());
}
$scheduleId = $row['eventId'];
$is_priority = $parsedRow->getInt('isPriority');
// Criteria
$criteriaNodes = [];
foreach ($schedule->criteria as $scheduleCriteria) {
$criteriaNode = $scheduleXml->createElement('criteria');
$criteriaNode->setAttribute('metric', $scheduleCriteria->metric);
$criteriaNode->setAttribute('condition', $scheduleCriteria->condition);
$criteriaNode->setAttribute('type', $scheduleCriteria->type);
$criteriaNode->textContent = $scheduleCriteria->value;
$criteriaNodes[] = $criteriaNode;
}
// Handle event type
if ($eventTypeId == Schedule::$LAYOUT_EVENT ||
$eventTypeId == Schedule::$INTERRUPT_EVENT ||
$eventTypeId == Schedule::$CAMPAIGN_EVENT ||
$eventTypeId == Schedule::$MEDIA_EVENT ||
$eventTypeId == Schedule::$PLAYLIST_EVENT ||
$eventTypeId == Schedule::$SYNC_EVENT
) {
// Ensure we have a layoutId (we may not if an empty campaign is assigned)
// https://github.com/xibosignage/xibo/issues/894
if ($layoutId == 0 || empty($layoutId)) {
$this->getLog()->info(sprintf('Player has empty event scheduled. Display = %s, EventId = %d', $this->display->display, $scheduleId));
continue;
}
// Check the layout status
// https://github.com/xibosignage/xibo/issues/743
if ($status > 3) {
$this->getLog()->info(sprintf('Player has invalid layout scheduled. Display = %s, LayoutId = %d', $this->display->display, $layoutId));
continue;
}
// Add a layout node to the schedule
$layout = $scheduleXml->createElement('layout');
$layout->setAttribute('file', $layoutId);
$layout->setAttribute('fromdt', $fromDt);
$layout->setAttribute('todt', $toDt);
$layout->setAttribute('scheduleid', $scheduleId);
$layout->setAttribute('priority', $is_priority);
$layout->setAttribute('syncEvent', ($row['eventTypeId'] == Schedule::$SYNC_EVENT) ? 1 : 0);
$layout->setAttribute('shareOfVoice', $row['shareOfVoice'] ?? 0);
$layout->setAttribute('duration', $duration ?? 0);
$layout->setAttribute('isGeoAware', $row['isGeoAware'] ?? 0);
$layout->setAttribute('geoLocation', $row['geoLocation'] ?? null);
$layout->setAttribute('cyclePlayback', $row['cyclePlayback'] ?? 0);
$layout->setAttribute('groupKey', $row['groupKey'] ?? 0);
$layout->setAttribute('playCount', $row['playCount'] ?? 0);
$layout->setAttribute('maxPlaysPerHour', $row['maxPlaysPerHour'] ?? 0);
// Handle dependents
if (array_key_exists($layoutId, $layoutDependents)) {
if ($options['dependentsAsNodes']) {
// Add the dependents to the layout as new nodes
$dependentNode = $scheduleXml->createElement('dependents');
foreach ($layoutDependents[$layoutId] as $storedAs) {
$fileNode = $scheduleXml->createElement('file', $storedAs);
$dependentNode->appendChild($fileNode);
}
$layout->appendChild($dependentNode);
} else {
// Add the dependents to the layout as an attribute
$layout->setAttribute('dependents', implode(',', $layoutDependents[$layoutId]));
}
}
// Add criteria notes
if (count($criteriaNodes) > 0) {
foreach ($criteriaNodes as $criteriaNode) {
$layout->appendChild($criteriaNode);
}
}
$layoutElements->appendChild($layout);
} elseif ($eventTypeId == Schedule::$COMMAND_EVENT) {
// Add a command node to the schedule
$command = $scheduleXml->createElement('command');
$command->setAttribute('date', $fromDt);
$command->setAttribute('scheduleid', $scheduleId);
$command->setAttribute('code', $commandCode);
// Add criteria notes
if (count($criteriaNodes) > 0) {
foreach ($criteriaNodes as $criteriaNode) {
$command->appendChild($criteriaNode);
}
}
$layoutElements->appendChild($command);
} elseif ($eventTypeId == Schedule::$OVERLAY_EVENT && $options['includeOverlays']) {
// Ensure we have a layoutId (we may not if an empty campaign is assigned)
// https://github.com/xibosignage/xibo/issues/894
if ($layoutId == 0 || empty($layoutId)) {
$this->getLog()->error(sprintf('Player has empty event scheduled. Display = %s, EventId = %d', $this->display->display, $scheduleId));
continue;
}
// Check the layout status
// https://github.com/xibosignage/xibo/issues/743
if (intval($row['status']) > 3) {
$this->getLog()->error(sprintf('Player has invalid layout scheduled. Display = %s, LayoutId = %d', $this->display->display, $layoutId));
continue;
}
if ($overlayNodes == null) {
$overlayNodes = $scheduleXml->createElement('overlays');
}
$overlay = $scheduleXml->createElement('overlay');
$overlay->setAttribute('file', $layoutId);
$overlay->setAttribute('fromdt', $fromDt);
$overlay->setAttribute('todt', $toDt);
$overlay->setAttribute('scheduleid', $scheduleId);
$overlay->setAttribute('priority', $is_priority);
$overlay->setAttribute('duration', $row['duration'] ?? 0);
$overlay->setAttribute('isGeoAware', $row['isGeoAware'] ?? 0);
$overlay->setAttribute('geoLocation', $row['geoLocation'] ?? null);
// Add criteria notes
if (count($criteriaNodes) > 0) {
foreach ($criteriaNodes as $criteriaNode) {
$overlay->appendChild($criteriaNode);
}
}
// Add to the overlays node list
$overlayNodes->appendChild($overlay);
} elseif ($eventTypeId == Schedule::$ACTION_EVENT) {
if ($actionNodes == null) {
$actionNodes = $scheduleXml->createElement('actions');
}
$action = $scheduleXml->createElement('action');
$action->setAttribute('fromdt', $fromDt);
$action->setAttribute('todt', $toDt);
$action->setAttribute('scheduleid', $scheduleId);
$action->setAttribute('priority', $is_priority);
$action->setAttribute('duration', $row['duration'] ?? 0);
$action->setAttribute('isGeoAware', $row['isGeoAware'] ?? 0);
$action->setAttribute('geoLocation', $row['geoLocation'] ?? null);
$action->setAttribute('triggerCode', $row['actionTriggerCode']);
$action->setAttribute('actionType', $row['actionType']);
$action->setAttribute('layoutCode', $row['actionLayoutCode']);
$action->setAttribute('commandCode', $commandCode);
// Add criteria notes
if (count($criteriaNodes) > 0) {
foreach ($criteriaNodes as $criteriaNode) {
$action->appendChild($criteriaNode);
}
}
$actionNodes->appendChild($action);
} else if ($eventTypeId === Schedule::$DATA_CONNECTOR_EVENT) {
if ($dataConnectorNodes == null) {
$dataConnectorNodes = $scheduleXml->createElement('dataConnectors');
}
$dataConnector = $scheduleXml->createElement('connector');
$dataConnector->setAttribute('fromdt', $fromDt);
$dataConnector->setAttribute('todt', $toDt);
$dataConnector->setAttribute('scheduleid', $scheduleId);
$dataConnector->setAttribute('priority', $is_priority);
$dataConnector->setAttribute('duration', $row['duration'] ?? 0);
$dataConnector->setAttribute('isGeoAware', $row['isGeoAware'] ?? 0);
$dataConnector->setAttribute('geoLocation', $row['geoLocation'] ?? null);
$dataConnector->setAttribute('dataSetId', $row['dataSetId']);
$dataConnector->setAttribute('dataParams', urlencode($row['dataSetParams']));
$dataConnector->setAttribute('js', 'dataSet_' . $row['dataSetId'] . '.js');
// Add criteria notes
if (count($criteriaNodes) > 0) {
foreach ($criteriaNodes as $criteriaNode) {
$dataConnector->appendChild($criteriaNode);
}
}
$dataConnectorNodes->appendChild($dataConnector);
}
}
}
// Add the overlay nodes if we had any
if ($overlayNodes != null) {
$layoutElements->appendChild($overlayNodes);
}
// Add Actions nodes if we had any
if ($actionNodes != null) {
$layoutElements->appendChild($actionNodes);
}
// Add Data Connector nodes if we had any
if ($dataConnectorNodes != null) {
$layoutElements->appendChild($dataConnectorNodes);
}
} catch (\Exception $e) {
$this->getLog()->error('Error getting the schedule. ' . $e->getMessage());
return new \SoapFault('Sender', 'Unable to get the schedule');
}
// Default Layout
try {
// is it valid?
$defaultLayout = $this->layoutFactory->getById($defaultLayoutId);
if ($defaultLayout->status >= Status::$STATUS_INVALID) {
$this->getLog()->error(sprintf('Player has invalid default Layout. Display = %s, LayoutId = %d',
$this->display->display,
$defaultLayout->layoutId));
}
// Are we interleaving the default? And is the default valid?
if ($this->display->incSchedule == 1 && $defaultLayout->status < Status::$STATUS_INVALID) {
// Add as a node at the end of the schedule.
$layout = $scheduleXml->createElement("layout");
$layout->setAttribute("file", $defaultLayoutId);
$layout->setAttribute("fromdt", '2000-01-01 00:00:00');
$layout->setAttribute("todt", '2030-01-19 00:00:00');
$layout->setAttribute("scheduleid", 0);
$layout->setAttribute("priority", 0);
$layout->setAttribute('duration', $defaultLayout->duration);
if ($options['dependentsAsNodes'] && array_key_exists($defaultLayoutId, $layoutDependents)) {
$dependentNode = $scheduleXml->createElement("dependents");
foreach ($layoutDependents[$defaultLayoutId] as $storedAs) {
$fileNode = $scheduleXml->createElement("file", $storedAs);
$dependentNode->appendChild($fileNode);
}
$layout->appendChild($dependentNode);
}
$layoutElements->appendChild($layout);
}
// Add on the default layout node
$default = $scheduleXml->createElement("default");
$default->setAttribute("file", $defaultLayoutId);
$default->setAttribute('duration', $defaultLayout->duration);
if ($options['dependentsAsNodes'] && array_key_exists($defaultLayoutId, $layoutDependents)) {
$dependentNode = $scheduleXml->createElement("dependents");
foreach ($layoutDependents[$defaultLayoutId] as $storedAs) {
$fileNode = $scheduleXml->createElement("file", $storedAs);
$dependentNode->appendChild($fileNode);
}
$default->appendChild($dependentNode);
}
$layoutElements->appendChild($default);
} catch (\Exception $exception) {
$this->getLog()->error('Default Layout Invalid: ' . $exception->getMessage());
// Add the splash screen on as the default layout (ID 0)
$default = $scheduleXml->createElement('default');
$default->setAttribute('file', 0);
$layoutElements->appendChild($default);
}
// Add on a list of global dependants
$globalDependents = $scheduleXml->createElement('dependants');
foreach ($moduleDependents as $dep) {
$dependent = $scheduleXml->createElement('file', $dep);
$globalDependents->appendChild($dependent);
}
$layoutElements->appendChild($globalDependents);
// Format the output
$scheduleXml->formatOutput = true;
$this->getLog()->debug($scheduleXml->saveXML());
$output = $scheduleXml->saveXML();
// Cache
$cache->set($output);
$cache->expiresAt($this->toFilter);
$this->getPool()->saveDeferred($cache);
// Log Bandwidth
$this->logBandwidth($this->display->displayId, Bandwidth::$SCHEDULE, strlen($output));
return $output;
}
/**
* @param $serverKey
* @param $hardwareKey
* @param $mediaId
* @param $type
* @param $reason
* @return bool|\SoapFault
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doBlackList($serverKey, $hardwareKey, $mediaId, $type, $reason)
{
return true;
}
/**
* @param $serverKey
* @param $hardwareKey
* @param $logXml
* @return bool
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doSubmitLog($serverKey, $hardwareKey, $logXml)
{
$this->logProcessor->setRoute('SubmitLog');
// Sanitize
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey
]);
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
// Auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Sender', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
// Load the XML into a DOMDocument
$document = new \DOMDocument('1.0');
if (!$document->loadXML($logXml)) {
$this->getLog()->error(
'Malformed XML from Player, this will be discarded. The Raw XML String provided is: ' . $logXml
);
$this->getLog()->debug('XML log: ' . $logXml);
return true;
}
// Current log level
$logLevel = \Xibo\Service\LogService::resolveLogLevel($this->display->getLogLevel());
$discardedLogs = 0;
// Store processed logs in an array
$logs = [];
foreach ($document->documentElement->childNodes as $node) {
/* @var \DOMElement $node */
// Make sure we don't consider any text nodes
if ($node->nodeType == XML_TEXT_NODE) {
continue;
}
// Zero out the common vars
$scheduleId = '';
$layoutId = '';
$mediaId = '';
$method = '';
$thread = '';
$type = '';
// This will be a bunch of trace nodes
$message = $node->textContent;
// Each element should have a category and a date
$date = $node->getAttribute('date');
$cat = strtolower($node->getAttribute('category'));
if ($date == '' || $cat == '') {
$this->getLog()->error('Log submitted without a date or category attribute');
continue;
}
// special handling for event
// this will create record in displayevent table
// and is not added to the logs.
if ($cat == 'event') {
$this->createDisplayAlert($node);
continue;
}
// Does this meet the current log level?
if ($cat == 'error') {
$recordLogLevel = Logger::ERROR;
$levelName = 'ERROR';
} else if ($cat == 'audit' || $cat == 'trace') {
$recordLogLevel = Logger::DEBUG;
$levelName = 'DEBUG';
} else if ($cat == 'debug') {
$recordLogLevel = Logger::INFO;
$levelName = 'INFO';
} else {
$recordLogLevel = Logger::NOTICE;
$levelName = 'NOTICE';
}
if ($recordLogLevel < $logLevel) {
$discardedLogs++;
continue;
}
// Adjust the date according to the display timezone
$date = $this->adjustDisplayLogDate($date, DateFormatHelper::getSystemFormat());
// Get the date and the message (all log types have these)
foreach ($node->childNodes as $nodeElements) {
if ($nodeElements->nodeName == 'scheduleID') {
$scheduleId = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'layoutID') {
$layoutId = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'mediaID') {
$mediaId = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'type') {
$type = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'method') {
$method = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'message') {
$message = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'thread') {
if ($nodeElements->textContent != '') {
$thread = '[' . $nodeElements->textContent . '] ';
}
}
}
// If the message is still empty, take the entire node content
if ($message == '') {
$message = $node->textContent;
}
// Add the IDs to the message
if ($scheduleId != '') {
$message .= ' scheduleId: ' . $scheduleId;
}
if ($layoutId != '') {
$message .= ' layoutId: ' . $layoutId;
}
if ($mediaId != '') {
$message .= ' mediaId: ' . $mediaId;
}
// Trim the page if it is over 50 characters.
$page = $thread . $method . $type;
if (strlen($page) >= 50) {
$page = substr($page, 0, 49);
}
$logs[] = [
$this->logProcessor->getUid(),
$date,
'PLAYER',
$levelName,
$page,
'POST',
$message,
0,
$this->display->displayId
];
}
if (count($logs) > 0) {
// Insert
$sql = '
INSERT INTO `log` (
`runNo`,
`logdate`,
`channel`,
`type`,
`page`,
`function`,
`message`,
`userid`,
`displayid`
) VALUES
';
// Build our query
$params = [];
// We're going to make params for each row/column
$i = 0;
$row = 0;
foreach ($logs as $log) {
$row++;
$sql .= '(';
foreach ($log as $field) {
$i++;
$key = $row . '_' . $i;
$sql .= ':' . $key . ',';
$params[$key] = $field;
}
$sql = rtrim($sql, ',');
$sql .= '),';
}
$sql = rtrim($sql, ',');
// Insert
$this->getStore()->update($sql, $params);
} else {
$this->getLog()->info('0 logs resolved from log package');
}
if ($discardedLogs > 0) {
$this->getLog()->info(
'Discarded ' . $discardedLogs . ' logs.
Consider adjusting your display profile log level. Resolved level is ' . $logLevel
);
}
$this->logBandwidth($this->display->displayId, Bandwidth::$SUBMITLOG, strlen($logXml));
return true;
}
/**
* @param $serverKey
* @param $hardwareKey
* @param $statXml
* @return bool
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doSubmitStats($serverKey, $hardwareKey, $statXml)
{
$this->logProcessor->setRoute('SubmitStats');
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey
]);
// Sanitize
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
// Auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Receiver', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
$this->getLog()->debug('Received XML. ' . $statXml);
if ($statXml == '') {
throw new \SoapFault('Receiver', 'Stat XML is empty.');
}
// Store an array of parsed stat data for insert
$now = Carbon::now();
// Get the display timezone to use when adjusting log dates.
$defaultTimeZone = $this->getConfig()->getSetting('defaultTimezone');
// Count stats processed from XML
$statCount = 0;
// Load the XML into a DOMDocument
$document = new \DOMDocument('1.0');
$document->loadXML($statXml);
$splashScreenErrorLogged = false;
$backgroundWidgetErrorLogged = false;
$widgetIdsNotFound = [];
$memoryCache = [];
// Cache of scheduleIds, counts and deleted entities
$schedules = [];
$campaigns = [];
$deletedScheduleIds = [];
$deletedCampaignIds = [];
foreach ($document->documentElement->childNodes as $node) {
/* @var \DOMElement $node */
// Make sure we don't consider any text nodes
if ($node->nodeType == XML_TEXT_NODE) {
continue;
}
// Each element should have these attributes
$fromDt = $node->getAttribute('fromdt');
$toDt = $node->getAttribute('todt');
$type = strtolower($node->getAttribute('type'));
$duration = $node->getAttribute('duration');
$count = $node->getAttribute('count');
$count = ($count != '') ? (int) $count : 1;
// Pull out engagements
$engagements = [];
foreach ($node->childNodes as $nodeElements) {
/* @var \DOMElement $nodeElements */
if ($nodeElements->nodeName == 'engagements') {
$i = 0;
foreach ($nodeElements->childNodes as $child) {
/* @var \DOMElement $child */
if ($child->nodeName == 'engagement') {
$engagements[$i]['tag'] = $child->getAttribute('tag');
$engagements[$i]['duration'] = (int) $child->getAttribute('duration');
$engagements[$i]['count'] = (int) $child->getAttribute('count');
$i++;
}
}
}
}
// Validate
// --------
// Check we have the minimum required data
if ($fromDt == '' || $toDt == '' || $type == '') {
$this->getLog()->info('Stat submitted without the fromdt, todt or type attributes.');
continue;
}
// Exactly the same dates are not supported
if ($fromDt == $toDt) {
$this->getLog()->debug('Ignoring a Stat record because the fromDt ('
. $fromDt. ') and toDt (' . $toDt. ') are the same');
continue;
}
// Adjust the date according to the display timezone
// stats are returned in player local date/time
// the CMS will have been configured with that Player's timezone, so we can convert accordingly.
try {
// From date
$fromDt = ($this->display->timeZone != null)
? Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $fromDt, $this->display->timeZone)
->tz($defaultTimeZone)
: Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $fromDt);
// To date
$toDt = ($this->display->timeZone != null)
? Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $toDt, $this->display->timeZone)
->tz($defaultTimeZone)
: Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $toDt);
// Do we need to set the duration of this record (we will do for older individually collected stats)
if ($duration == '') {
$duration = $toDt->diffInSeconds($fromDt);
}
} catch (\Exception $e) {
// Protect against the date format being unreadable
$this->getLog()->error('Stat with a from or to date that cannot be understood. fromDt: '
. $fromDt . ', toDt: ' . $toDt . '. E = ' . $e->getMessage());
continue;
}
// From date cannot be ahead of to date
if ($fromDt > $toDt) {
$this->getLog()->debug('Ignoring a Stat record because the fromDt ('
. $fromDt . ') is greater than toDt (' . $toDt . ')');
continue;
}
// check maximum retention period against stat date, do not record if it's older than max stat age
$maxAge = intval($this->getConfig()->getSetting('MAINTENANCE_STAT_MAXAGE'));
if ($maxAge != 0) {
$maxAgeDate = Carbon::now()->subDays($maxAge);
if ($toDt->isBefore($maxAgeDate)) {
$this->getLog()->debug('Stat older than max retention period, skipping.');
continue;
}
}
// If the duration is enormous, then we have an erroneous message from the player
if ($duration > (86400 * 365)) {
$this->getLog()->debug('Dates are too far apart');
continue;
}
// Simple validation end
// ---------------------
// from here on we need to look things up
// ScheduleId is supplied to all layout stats, but not event stats.
$scheduleId = $node->getAttribute('scheduleid');
if (empty($scheduleId)) {
$scheduleId = 0;
}
$layoutId = $node->getAttribute('layoutid');
// Ignore the splash screen
if ($layoutId == 'splash') {
// only logging this message one time
if (!$splashScreenErrorLogged) {
$splashScreenErrorLogged = true;
$this->getLog()->info('Splash Screen Statistic Ignored');
}
continue;
}
// Slightly confusing behaviour here to support old players without introduction a different call in
// XMDS v=5.
// MediaId is actually the widgetId (since 1.8) and the mediaId is looked up by this service
$widgetId = $node->getAttribute('mediaid');
$mediaId = null;
// Ignore old "background" stat records.
if ($widgetId === 'background') {
if (!$backgroundWidgetErrorLogged) {
$backgroundWidgetErrorLogged = true;
$this->getLog()->info('Ignoring old "background" stat record.');
}
continue;
}
// The mediaId (really widgetId) might well be null
if ($widgetId == 'null' || $widgetId == '') {
$widgetId = 0;
} else {
// Try to get details for this widget
try {
if (in_array($widgetId, $widgetIdsNotFound)) {
continue;
}
// Do we have it in cache?
if (!array_key_exists('w_' . $widgetId, $memoryCache)) {
$memoryCache['w_' . $widgetId] = $this->widgetFactory->getMediaByWidgetId($widgetId);
}
$mediaId = $memoryCache['w_' . $widgetId];
// If the mediaId is empty, then we can assume we're a stat for a region specific widget
if ($mediaId === null) {
$type = 'widget';
}
} catch (NotFoundException $notFoundException) {
// Widget isn't found
// we can only log this and move on
// only logging this message one time
if (!in_array($widgetId, $widgetIdsNotFound)) {
$widgetIdsNotFound[] = $widgetId;
$this->getLog()->error('Stat for a widgetId that doesnt exist: ' . $widgetId);
}
continue;
}
}
$tag = $node->getAttribute('tag');
if ($tag == 'null') {
$tag = null;
}
// Cache a count for this scheduleId
$parentCampaignId = 0;
$parentCampaign = null;
if ($scheduleId > 0 && !in_array($scheduleId, $deletedScheduleIds)) {
try {
// Lookup this schedule
if (!array_key_exists($scheduleId, $schedules)) {
// Look up the campaign.
$schedules[$scheduleId] = $this->scheduleFactory->getById($scheduleId);
}
$parentCampaignId = $schedules[$scheduleId]->parentCampaignId ?? 0;
} catch (NotFoundException $notFoundException) {
$this->getLog()->error('Schedule with ID ' . $scheduleId . ' no-longer exists');
$deletedScheduleIds[] = $scheduleId;
}
// Does this event have a parent campaign?
if (!empty($parentCampaignId) && !in_array($parentCampaignId, $deletedCampaignIds)) {
try {
// Look it up
if (!array_key_exists($parentCampaignId, $campaigns)) {
$campaigns[$parentCampaignId] = $this->campaignFactory->getById($parentCampaignId);
}
// Set the parent campaign so that it is recorded with the stat record
$parentCampaign = $campaigns[$parentCampaignId];
// For a layout stat we should increment the number of plays on the Campaign
if ($type === 'layout' && $campaigns[$parentCampaignId]->type === 'ad') {
// spend/impressions multiplier for this display
$spend = empty($this->display->costPerPlay)
? 0
: ($count * $this->display->costPerPlay);
$impressions = empty($this->display->impressionsPerPlay)
? 0
: ($count * $this->display->impressionsPerPlay);
// record
$parentCampaign->incrementPlays($count, $spend, $impressions);
}
} catch (NotFoundException $notFoundException) {
$deletedCampaignIds[] = $parentCampaignId;
$this->getLog()->error('Campaign with ID ' . $parentCampaignId . ' no-longer exists');
}
}
}
// Important - stats will now send display entity instead of displayId
$stats = [
'type' => $type,
'statDate' => $now,
'fromDt' => $fromDt,
'toDt' => $toDt,
'scheduleId' => $scheduleId,
'display' => $this->display,
'layoutId' => (int) $layoutId,
'mediaId' => $mediaId,
'tag' => $tag,
'widgetId' => (int) $widgetId,
'duration' => (int) $duration,
'count' => $count,
'engagements' => (count($engagements) > 0) ? $engagements : [],
'parentCampaignId' => $parentCampaignId,
'parentCampaign' => $parentCampaign,
];
$this->getTimeSeriesStore()->addStat($stats);
$statCount++;
}
// Insert stats
if ($statCount > 0) {
$this->getTimeSeriesStore()->addStatFinalize();
} else {
$this->getLog()->info('0 stats resolved from data package');
}
// Save ad campaign changes.
foreach ($campaigns as $campaign) {
if ($campaign->type === 'ad') {
$campaign->saveIncrementPlays();
}
}
$this->logBandwidth($this->display->displayId, Bandwidth::$SUBMITSTATS, strlen($statXml));
return true;
}
/**
* @param $serverKey
* @param $hardwareKey
* @param $inventory
* @return bool
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doMediaInventory($serverKey, $hardwareKey, $inventory)
{
$this->logProcessor->setRoute('MediaInventory');
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey
]);
// Sanitize
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
// Auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Receiver', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
$this->getLog()->debug($inventory);
// Check that the $inventory contains something
if ($inventory == '') {
throw new \SoapFault('Receiver', 'Inventory Cannot be Empty');
}
// Load the XML into a DOMDocument
$document = new \DOMDocument('1.0');
$document->loadXML($inventory);
// Assume we are complete (but we are getting some)
$mediaInventoryComplete = 1;
$xpath = new \DOMXPath($document);
$fileNodes = $xpath->query('//file');
foreach ($fileNodes as $node) {
/* @var \DOMElement $node */
// What type of file?
try {
$requiredFile = null;
switch ($node->getAttribute('type')) {
case 'media':
$requiredFile = $this->requiredFileFactory->getByDisplayAndMedia(
$this->display->displayId,
$node->getAttribute('id'),
$node->getAttribute('id') < 0 ? 'P' : 'M'
);
break;
case 'layout':
$requiredFile = $this->requiredFileFactory->getByDisplayAndLayout(
$this->display->displayId,
$node->getAttribute('id')
);
break;
case 'resource':
$requiredFile = $this->requiredFileFactory->getByDisplayAndWidget(
$this->display->displayId,
$node->getAttribute('id')
);
break;
case 'dependency':
$requiredFile = $this->requiredFileFactory->getByDisplayAndDependency(
$this->display->displayId,
$node->getAttribute('fileType'),
$node->getAttribute('id')
);
break;
default:
$this->getLog()->debug(sprintf(
'Skipping unknown node in media inventory: %s - %s.',
$node->getAttribute('type'),
$node->getAttribute('id')
));
// continue drops out the switch, continue again goes to the top of the foreach
continue 2;
}
// File complete?
$complete = $node->getAttribute('complete');
$requiredFile->complete = $complete;
$requiredFile->save();
// If this item is a 0 then set not complete
if ($complete == 0) {
$mediaInventoryComplete = 2;
}
} catch (NotFoundException $e) {
$this->getLog()->error('Unable to find file in media inventory: '
. $node->getAttribute('type') . '. ' . $node->getAttribute('id'));
}
}
$this->display->mediaInventoryStatus = $mediaInventoryComplete;
// Only call save if this property has actually changed.
if ($this->display->hasPropertyChanged('mediaInventoryStatus')) {
$this->getLog()->debug('Media Inventory status changed to ' . $this->display->mediaInventoryStatus);
// If we are complete, then drop the player nonce cache
if ($this->display->mediaInventoryStatus == 1) {
$this->getLog()->debug('Media Inventory tells us that all downloads are complete');
}
$this->display->saveMediaInventoryStatus();
}
$this->logBandwidth($this->display->displayId, Bandwidth::$MEDIAINVENTORY, strlen($inventory));
return true;
}
/**
* Get Resource for XMDS v6 and lower
* outputs the HTML with data included
* @param string $serverKey
* @param string $hardwareKey
* @param integer $layoutId
* @param string $regionId
* @param string $mediaId
* @param bool $isSupportsDataUrl Does the callee support data URLs in widgets?
* @return mixed
* @throws NotFoundException
* @throws \SoapFault
*/
protected function doGetResource(
$serverKey,
$hardwareKey,
$layoutId,
$regionId,
$mediaId,
bool $isSupportsDataUrl = false
) {
$this->logProcessor->setRoute('GetResource');
$sanitizer = $this->getSanitizer([
'serverKey' => $serverKey,
'hardwareKey' => $hardwareKey,
'layoutId' => $layoutId,
'regionId' => $regionId,
'mediaId' => $mediaId
]);
// Sanitize
$serverKey = $sanitizer->getString('serverKey');
$hardwareKey = $sanitizer->getString('hardwareKey');
$layoutId = $sanitizer->getInt('layoutId');
$regionId = $sanitizer->getString('regionId');
$mediaId = $sanitizer->getString('mediaId');
// Check the serverKey matches
if ($serverKey != $this->getConfig()->getSetting('SERVER_KEY')) {
throw new \SoapFault(
'Sender',
'The Server key you entered does not match with the server key at this address'
);
}
// Auth this request...
if (!$this->authDisplay($hardwareKey)) {
throw new \SoapFault('Receiver', 'This Display is not authorised.');
}
// Now that we authenticated the Display, make sure we are sticking to our bandwidth limit
if (!$this->checkBandwidth($this->display->displayId)) {
throw new \SoapFault('Receiver', 'Bandwidth Limit exceeded');
}
// The MediaId is actually the widgetId
try {
$requiredFile = $this->requiredFileFactory->getByDisplayAndWidget(
$this->display->displayId,
$mediaId
);
$region = $this->regionFactory->getById($regionId);
$widget = $this->widgetFactory->loadByWidgetId($mediaId);
// If this is a canvas region we add all our widgets to this.
if ($region->type === 'canvas') {
// Render a canvas
// ---------------
// A canvas plays all widgets in the region at once.
// none of them will be anything other than elements
$widgets = $region->getPlaylist()->widgets;
} else {
// Render a widget in a region
// ---------------------------
// We have a widget
$widgets = [$widget];
}
// Module is always the first widget
$module = $this->moduleFactory->getByType($widget->type);
// Get all templates
$templates = $this->widgetFactory->getTemplatesForWidgets($module, $widgets);
$renderer = $this->moduleFactory->createWidgetHtmlRenderer();
$resource = $renderer->renderOrCache(
$region,
$widgets,
$templates
);
// An array of media we have access to.
// Get all linked media for this player and this widget.
$media = [];
$widgetIds = implode(',', array_map(function ($el) {
return $el->widgetId;
}, $widgets));
$sql = '
SELECT `media`.mediaId, `media`.storedAs
FROM `media`
INNER JOIN `lkwidgetmedia`
ON `lkwidgetmedia`.mediaId = `media`.mediaId
WHERE `lkwidgetmedia`.widgetId IN (' . $widgetIds . ')
UNION ALL
SELECT `media`.mediaId, `media`.storedAs
FROM `media`
INNER JOIN `display_media`
ON `display_media`.mediaId = `media`.mediaId
WHERE `display_media`.displayId = :displayId
';
// There isn't any point using a prepared statement because the widgetIds are substituted at runtime
foreach ($this->getStore()->select($sql, [
'displayId' => $this->display->displayId
]) as $row) {
$media[$row['mediaId']] = $row['storedAs'];
};
// If this player doesn't support data URLs, then add the data to this response.
$data = [];
if (!$isSupportsDataUrl) {
foreach ($widgets as $widget) {
$dataModule = $this->moduleFactory->getByType($widget->type);
if ($dataModule->isDataProviderExpected()) {
// We only ever return cache.
$dataProvider = $dataModule->createDataProvider($widget);
$dataProvider->setDisplayProperties(
$this->display->latitude ?: $this->getConfig()->getSetting('DEFAULT_LAT'),
$this->display->longitude ?: $this->getConfig()->getSetting('DEFAULT_LONG'),
$this->display->displayId
);
// Use the cache if we can.
try {
$widgetDataProviderCache = $this->moduleFactory->createWidgetDataProviderCache();
$cacheKey = $this->moduleFactory->determineCacheKey(
$dataModule,
$widget,
$this->display->displayId,
$dataProvider,
$dataModule->getWidgetProviderOrNull()
);
// We do not pass a modifiedDt in here because we always expect to be cached.
if (!$widgetDataProviderCache->decorateWithCache($dataProvider, $cacheKey, null, false)) {
throw new NotFoundException('Cache not ready');
}
$widgetData = $widgetDataProviderCache->decorateForPlayer(
$this->configService,
$this->display,
$this->configService->getApiKeyDetails()['encryptionKey'],
$dataProvider->getData(),
$media,
);
} catch (GeneralException $exception) {
// No data cached yet, exception
$this->getLog()->error('getResource: Failed to get data cache for widgetId '
. $widget->widgetId . ', e: ' . $exception->getMessage());
throw new \SoapFault('Receiver', 'Cache not ready');
}
$data[$widget->widgetId] = [
'data' => $widgetData,
'meta' => $dataProvider->getMeta()
];
}
}
}
// Decorate for the player
$resource = $renderer->decorateForPlayer(
$this->display,
$resource,
$media,
$isSupportsDataUrl,
$data,
$this->moduleFactory->getAssetsFromTemplates($templates)
);
if ($resource == '') {
throw new ControllerNotImplemented();
}
// Log bandwidth
$requiredFile->bytesRequested = $requiredFile->bytesRequested + strlen($resource);
$requiredFile->save();
} catch (NotFoundException) {
throw new \SoapFault('Receiver', 'Requested an invalid file.');
} catch (\Exception $e) {
// Pass soap faults straight through.
if ($e instanceof \SoapFault) {
throw $e;
}
$this->getLog()->error('Unknown error during getResource. E = ' . $e->getMessage());
$this->getLog()->debug($e->getTraceAsString());
throw new \SoapFault('Receiver', 'Unable to get the media resource');
}
// Log Bandwidth
$this->logBandwidth($this->display->displayId, Bandwidth::$GETRESOURCE, strlen($resource));
return $resource;
}
/**
* Authenticates the display
* @param string $hardwareKey
* @return bool
*/
protected function authDisplay($hardwareKey)
{
try {
$this->display = $this->displayFactory->getByLicence($hardwareKey);
if ($this->display->licensed != 1) {
return false;
}
// Configure our log processor
$this->logProcessor->setDisplay($this->display->displayId, $this->display->isAuditing());
return true;
} catch (NotFoundException $e) {
$this->getLog()->error($e->getMessage());
return false;
}
}
/**
* Alert Display Up
* assesses whether a notification is required to be sent for this display, and only does something if the
* display is currently marked as offline (i.e. it is coming back online again)
* this is only called in Register
* @throws NotFoundException
*/
protected function alertDisplayUp(): void
{
$maintenanceEnabled = $this->getConfig()->getSetting('MAINTENANCE_ENABLED');
if ($this->display->loggedIn == 0 && !empty($this->display->displayId)) {
$this->getLog()->info(sprintf('Display %s was down, now its up.', $this->display->display));
// Log display up
$this->displayEventFactory->createEmpty()->eventEnd($this->display->displayId);
// Do we need to email?
if ($this->display->emailAlert == 1
&& ($maintenanceEnabled == 'On' || $maintenanceEnabled == 'Protected')
&& $this->getConfig()->getSetting('MAINTENANCE_EMAIL_ALERTS') == 1
) {
// Only send alerts during operating hours.
if ($this->isInsideOperatingHours()) {
$subject = sprintf(__('Recovery for Display %s'), $this->display->display);
$body = sprintf(
__('Display ID %d is now back online %s'),
$this->display->displayId,
Carbon::now()->format(DateFormatHelper::getSystemFormat())
);
// Create a notification assigned to system-wide user groups
try {
$notification = $this->notificationFactory->createSystemNotification(
$subject,
$body,
Carbon::now(),
'display',
);
// Get groups which have been configured to receive notifications
foreach ($this->userGroupFactory
->getDisplayNotificationGroups($this->display->displayGroupId) as $group) {
$notification->assignUserGroup($group);
}
// Save the notification and insert the links, etc.
$notification->save();
} catch (\Exception) {
$this->getLog()->error(sprintf(
'Unable to send email alert for display %s with subject %s and body %s',
$this->display->display,
$subject,
$body
));
}
} else {
$this->getLog()->info('Not sending recovery email for Display - '
. $this->display->display . ' we are outside of its operating hours');
}
} else {
$this->getLog()->debug(sprintf(
'No email required. Email Alert: %d, Enabled: %s, Email Enabled: %s.',
$this->display->emailAlert,
$maintenanceEnabled,
$this->getConfig()->getSetting('MAINTENANCE_EMAIL_ALERTS')
));
}
}
}
/**
* Is the display currently inside operating hours?
* @return bool
* @throws \Xibo\Support\Exception\NotFoundException
*/
private function isInsideOperatingHours(): bool
{
$dayPartId = $this->display->getSetting('dayPartId', null, ['displayOverride' => true]);
// If dayPart is configured, check operating hours
if ($dayPartId !== null) {
try {
$dayPart = $this->dayPartFactory->getById($dayPartId);
$startTimeArray = explode(':', $dayPart->startTime);
$startTime = Carbon::now()->setTime(intval($startTimeArray[0]), intval($startTimeArray[1]));
$endTimeArray = explode(':', $dayPart->endTime);
$endTime = Carbon::now()->setTime(intval($endTimeArray[0]), intval($endTimeArray[1]));
$now = Carbon::now();
// handle exceptions
foreach ($dayPart->exceptions as $exception) {
// check if we are on exception day and if so override the startTime and endTime accordingly
if ($exception['day'] == Carbon::now()->format('D')) {
// Parse the start/end times into the current day.
$exceptionsStartTime = explode(':', $exception['start']);
$startTime = Carbon::now()->setTime(
intval($exceptionsStartTime[0]),
intval($exceptionsStartTime[1])
);
$exceptionsEndTime = explode(':', $exception['end']);
$endTime = Carbon::now()->setTime(
intval($exceptionsEndTime[0]),
intval($exceptionsEndTime[1])
);
}
}
// check if we are inside the operating hours for this display - we use that flag to decide
// if we need to create a notification and send an email.
return ($now >= $startTime && $now <= $endTime);
} catch (NotFoundException) {
$this->getLog()->debug('Unknown dayPartId set on Display Profile for displayId '
. $this->display->displayId);
}
}
// Otherwise, assume CMS is within operating hours.
return true;
}
/**
* Get the Client IP Address
* @return string
*/
protected function getIp()
{
$clientIp = '';
$keys = array('X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR', 'CLIENT_IP', 'REMOTE_ADDR');
foreach ($keys as $key) {
if (isset($_SERVER[$key]) && filter_var($_SERVER[$key], FILTER_VALIDATE_IP) !== false) {
$clientIp = $_SERVER[$key];
break;
}
}
return $clientIp;
}
/**
* Check we haven't exceeded the bandwidth limits
* - Note, display logging doesn't work in here, this is CMS level logging
*
* @param int $displayId The Display ID
* @return bool true if the check passes, false if it fails
* @throws NotFoundException
*/
protected function checkBandwidth($displayId)
{
// Uncomment to enable auditing.
//$this->logProcessor->setDisplay(0, 'debug');
$this->display = $this->displayFactory->getById($displayId);
$xmdsLimit = intval($this->getConfig()->getSetting('MONTHLY_XMDS_TRANSFER_LIMIT_KB'));
$displayBandwidthLimit = $this->display->bandwidthLimit;
try {
$bandwidthUsage = 0;
if ($this->bandwidthFactory->isBandwidthExceeded($xmdsLimit, $bandwidthUsage)) {
// Bandwidth Exceeded
// Create a notification if we don't already have one today for this display.
$subject = __('Bandwidth allowance exceeded');
$date = Carbon::now();
$notifications = $this->notificationFactory->getBySubjectAndDate(
$subject,
$date->startOfDay()->format('U'),
$date->addDay()->startOfDay()->format('U')
);
if (count($notifications) <= 0) {
$body = __(
sprintf(
'Bandwidth allowance of %s exceeded. Used %s',
ByteFormatter::format($xmdsLimit * 1024),
ByteFormatter::format($bandwidthUsage)
)
);
$notification = $this->notificationFactory->createSystemNotification(
$subject,
$body,
Carbon::now(),
'library'
);
$notification->save();
$this->getLog()->critical($subject);
}
return false;
} elseif ($this->bandwidthFactory->isBandwidthExceeded(
$displayBandwidthLimit,
$bandwidthUsage,
$displayId
)
) {
// Bandwidth Exceeded
// Create a notification if we don't already have one today for this display.
$subject = __(sprintf('Display ID %d exceeded the bandwidth limit', $this->display->displayId));
$date = Carbon::now();
$notifications = $this->notificationFactory->getBySubjectAndDate(
$subject,
$date->startOfDay()->format('U'),
$date->addDay()->startOfDay()->format('U')
);
if (count($notifications) <= 0) {
$body = __(
sprintf(
'Display bandwidth limit %s exceeded. Used %s for Display Id %d',
ByteFormatter::format($displayBandwidthLimit * 1024),
ByteFormatter::format($bandwidthUsage),
$this->display->displayId
)
);
$notification = $this->notificationFactory->createSystemNotification(
$subject,
$body,
Carbon::now(),
'display'
);
// Add in any displayNotificationGroups, with permissions
foreach ($this->userGroupFactory->getDisplayNotificationGroups(
$this->display->displayGroupId
) as $group) {
$notification->assignUserGroup($group);
}
$notification->save();
$this->getLog()->critical($subject);
}
return false;
} else {
// Bandwidth not exceeded.
return true;
}
} catch (\Exception $e) {
$this->getLog()->error($e->getMessage());
return false;
}
}
/**
* Log Bandwidth Usage
* @param int $displayId
* @param string $type
* @param int $sizeInBytes
*/
protected function logBandwidth($displayId, $type, $sizeInBytes)
{
$this->bandwidthFactory->createAndSave($type, $displayId, $sizeInBytes);
}
/**
* Add a dependency to the provided DOM element
* @param array $rfIds
* @param \DOMDocument $requiredFilesXml
* @param \DOMElement $fileElements
* @param bool $httpDownloads
* @param bool $isSupportsDependency
* @param Dependency $dependency
* @throws NotFoundException
* @throws \DOMException
*/
private function addDependency(
array &$rfIds,
\DOMDocument $requiredFilesXml,
\DOMElement $fileElements,
bool $httpDownloads,
bool $isSupportsDependency,
Dependency $dependency
): void {
// Create a required file for this dependency
$dependencyBasePath = basename($dependency->path);
$rfId = $this->requiredFileFactory
->createForGetDependency(
$this->display->displayId,
$dependency->fileType,
$dependency->legacyId,
$dependency->id,
$dependencyBasePath,
$dependency->size,
$isSupportsDependency
)
->save()->rfId;
// Make sure we do not already have it.
if (in_array($rfId, $rfIds)) {
$this->getLog()->debug('addDependency: ' . $dependency->id . ' already added to XML');
return;
}
// Record this required file's ID as a new one.
$rfIds[] = $rfId;
// Add to RF XML
$file = $requiredFilesXml->createElement('file');
// HTTP downloads?
// 3) some dependencies don't support HTTP downloads because they aren't in the library
$httpFilePath = null;
if ($httpDownloads && $dependency->isAvailableOverHttp) {
$httpFilePath = LinkSigner::generateSignedLink(
$this->display,
$this->configService->getApiKeyDetails()['encryptionKey'],
$this->configService->getSetting('CDN_URL'),
RequiredFile::$TYPE_DEPENDENCY,
$dependency->id,
$dependencyBasePath,
$dependency->fileType,
);
$file->setAttribute('download', 'http');
} else {
$file->setAttribute('download', 'xmds');
}
$file->setAttribute('size', $dependency->size);
$file->setAttribute('md5', $dependency->md5);
$file->setAttribute('saveAs', $dependencyBasePath);
// 4) earlier versions of XMDS do not support GetDependency, and will therefore need to have their
// dependencies added as media nodes.
if ($isSupportsDependency) {
// Soap7+: GetDependency supported
$file->setAttribute('type', 'dependency');
$file->setAttribute('fileType', $dependency->fileType);
if ($httpFilePath !== null) {
$file->setAttribute('path', $httpFilePath);
} else {
$file->setAttribute('path', $dependencyBasePath);
}
$file->setAttribute('saveAs', $dependencyBasePath);
$file->setAttribute('id', $dependency->id);
} else {
// We have no choice but to pretend we're a media download.
// Soap3/4 are modified to cater for this.
// Soap3: players read, send and save using the `path`. Expects `id.ext`.
// Soap4: we only have the ID, but we can use HTTP downloads.
// Soap5,6,7: use Soap4
$file->setAttribute('type', 'media');
if ($httpFilePath !== null) {
$file->setAttribute('path', $httpFilePath);
} else {
$file->setAttribute('path', $dependencyBasePath);
}
$file->setAttribute('id', $dependency->legacyId);
$file->setAttribute('fileType', 'media');
// We need an extra attribute so that we can retrieve the original asset type from cache.
$file->setAttribute('realId', $dependency->id);
$file->setAttribute('assetType', $dependency->fileType);
}
// Add our node
$fileElements->appendChild($file);
}
/**
* Set Date Filters
*/
protected function setDateFilters()
{
// Hour to hour time bands for the query
// Rf lookahead is the number of seconds ahead we should consider.
// it may well be less than 1 hour, and if so we cannot do hour to hour time bands, we need to do
// now, forwards.
// Start with now:
$fromFilter = Carbon::now();
// If this Display is in a different timezone, then we need to set that here for these filter criteria
if (!empty($this->display->timeZone)) {
$fromFilter->setTimezone($this->display->timeZone);
}
// TODO use new sanitizer here
//$rfLookAhead = $this->getSanitizer()->int($this->getConfig()->getSetting('REQUIRED_FILES_LOOKAHEAD'));
$rfLookAhead = $this->getConfig()->getSetting('REQUIRED_FILES_LOOKAHEAD');
if ($rfLookAhead >= 3600) {
// Go from the top of this hour
$fromFilter
->minute(0)
->second(0);
}
// If we're set to look ahead, then do so - otherwise grab only a 1 hour slice
if ($this->getConfig()->getSetting('SCHEDULE_LOOKAHEAD') == 1) {
$toFilter = $fromFilter->copy()->addSeconds($rfLookAhead);
} else {
$toFilter = $fromFilter->copy()->addHour();
}
// Make sure our filters are expressed in CMS time, so that when we run the query we don't lose the timezone
$this->localFromFilter = $fromFilter;
$this->localToFilter = $toFilter;
$this->fromFilter = Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $fromFilter);
$this->toFilter = Carbon::createFromFormat(DateFormatHelper::getSystemFormat(), $toFilter);
$this->getLog()->debug(
sprintf(
'FromDT = %s [%d]. ToDt = %s [%d]',
$fromFilter->toRssString(),
$fromFilter->format('U'),
$toFilter->toRssString(),
$toFilter->format('U')
)
);
}
/**
* Adjust the log date according to the Display timezone.
* Return current date if we fail.
* @param string $date
* @param string $format
* @return string
*/
protected function adjustDisplayLogDate(string $date, string $format): string
{
// Get the display timezone to use when adjusting log dates.
$defaultTimeZone = $this->getConfig()->getSetting('defaultTimezone');
// Adjust the date according to the display timezone
try {
$date = ($this->display->timeZone != null)
? Carbon::createFromFormat(
DateFormatHelper::getSystemFormat(),
$date,
$this->display->timeZone
)->tz($defaultTimeZone)
: Carbon::createFromFormat(
DateFormatHelper::getSystemFormat(),
$date
);
$date = $date->format($format);
} catch (\Exception $e) {
// Protect against the date format being unreadable
$this->getLog()->debug('Date format unreadable on log message: ' . $date);
// Use now instead
$date = Carbon::now()->format($format);
}
return $date;
}
private function createDisplayAlert(\DomElement $alertNode)
{
$date = $this->adjustDisplayLogDate($alertNode->getAttribute('date'), 'U');
$eventType = '';
$refId = '';
$detail = '';
$alertType = '';
// Get the nodes we are expecting
foreach ($alertNode->childNodes as $nodeElements) {
if ($nodeElements->nodeName == 'eventType') {
$eventType = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'refId') {
$refId = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'message') {
$detail = $nodeElements->textContent;
} else if ($nodeElements->nodeName == 'alertType') {
$alertType = $nodeElements->textContent;
}
}
// if alerts should provide both start and end or just start
if ($alertType == 'both' || $alertType == 'start') {
$displayEvent = $this->displayEventFactory->createEmpty();
// new record populated from the submitLog xml.
$displayEvent->displayId = $this->display->displayId;
$displayEvent->eventTypeId = $displayEvent->getEventIdFromString($eventType);
$displayEvent->eventDate = $date;
$displayEvent->start = $date;
$displayEvent->end = $alertType == 'both' ? $date : null;
$displayEvent->refId = empty($refId) ? null : $refId;
$displayEvent->detail = $detail;
$displayEvent->save();
} else if ($alertType == 'end') {
// if this event pertain only to end date for an existing event record,
// then set the end date for this display and the specified eventType
$displayEvent = $this->displayEventFactory->createEmpty();
$eventTypeId = $displayEvent->getEventIdFromString($eventType);
empty($refId)
? $displayEvent->eventEnd($this->display->displayId, $eventTypeId, $detail, $date)
: $displayEvent->eventEndByReference($this->display->displayId, $eventTypeId, $refId, $detail);
}
}
/**
* Collection Interval with offset
* calculates an offset for the collection interval based on the displayId and returns it
* the offset is plus or minus 10 seconds and will always be the same when given the same displayId
* @param int $collectionInterval
* @return int
*/
protected function collectionIntervalWithOffset(int $collectionInterval): int
{
if ($collectionInterval <= 60) {
$offset = $this->display->displayId % 10;
return $collectionInterval + ($offset <= 5 ? $offset * -1 : $offset - 5);
} else {
$offset = $this->display->displayId % 20;
return $collectionInterval + ($offset <= 10 ? $offset * -1 : $offset - 10);
}
}
}
Reference in New Issue Copy Permalink