650 lines
18 KiB
PHP
650 lines
18 KiB
PHP
<?php
|
|
/*
|
|
* Copyright (C) 2024 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\Entity;
|
|
|
|
use Respect\Validation\Validator as v;
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
|
use Xibo\Factory\ModuleFactory;
|
|
use Xibo\Service\LogServiceInterface;
|
|
use Xibo\Storage\StorageServiceInterface;
|
|
use Xibo\Support\Exception\InvalidArgumentException;
|
|
use Xibo\Widget\Definition\LegacyType;
|
|
use Xibo\Widget\Provider\DataProvider;
|
|
use Xibo\Widget\Provider\WidgetCompatibilityInterface;
|
|
use Xibo\Widget\Provider\WidgetProviderInterface;
|
|
use Xibo\Widget\Provider\WidgetValidatorInterface;
|
|
|
|
/**
|
|
* Class Module
|
|
* @package Xibo\Entity
|
|
* @SWG\Definition()
|
|
*/
|
|
class Module implements \JsonSerializable
|
|
{
|
|
use EntityTrait;
|
|
use ModulePropertyTrait;
|
|
|
|
/**
|
|
* @SWG\Property(description="The ID of this Module")
|
|
* @var int
|
|
*/
|
|
public $moduleId;
|
|
|
|
/**
|
|
* @SWG\Property(description="Module Name")
|
|
* @var string
|
|
*/
|
|
public $name;
|
|
|
|
/**
|
|
* @SWG\Property(description="Module Author")
|
|
* @var string
|
|
*/
|
|
public $author;
|
|
|
|
/**
|
|
* @SWG\Property(description="Description of the Module")
|
|
* @var string
|
|
*/
|
|
public $description;
|
|
|
|
/**
|
|
* @SWG\Property(description="An icon to use in the toolbar")
|
|
* @var string
|
|
*/
|
|
public $icon;
|
|
|
|
/**
|
|
* @SWG\Property(description="The type code for this module")
|
|
* @var string
|
|
*/
|
|
public $type;
|
|
|
|
/**
|
|
* @SWG\Property(description="Legacy type codes for this module")
|
|
* @var LegacyType[]
|
|
*/
|
|
public $legacyTypes;
|
|
|
|
/**
|
|
* @SWG\Property(description="The data type of the data expected to be returned by this modules data provider")
|
|
* @var string
|
|
*/
|
|
public $dataType;
|
|
|
|
/**
|
|
* @SWG\Property(description="The group details for this module")
|
|
* @var string[]
|
|
*/
|
|
public $group;
|
|
|
|
/**
|
|
* @SWG\Property(description="The cache key used when requesting data")
|
|
* @var string
|
|
*/
|
|
public $dataCacheKey;
|
|
|
|
/**
|
|
* @SWG\Property(description="Is fallback data allowed for this module? Only applicable for a Data Widget")
|
|
* @var int
|
|
*/
|
|
public $fallbackData;
|
|
|
|
/**
|
|
* @SWG\Property(description="Is specific to a Layout or can be uploaded to the Library?")
|
|
* @var int
|
|
*/
|
|
public $regionSpecific;
|
|
|
|
/**
|
|
* @SWG\Property(description="The schema version of the module")
|
|
* @var int
|
|
*/
|
|
public $schemaVersion;
|
|
|
|
/**
|
|
* @SWG\Property(description="The compatibility class of the module")
|
|
* @var string
|
|
*/
|
|
public $compatibilityClass = null;
|
|
|
|
/**
|
|
* @SWG\Property(description="A flag indicating whether the module should be excluded from the Layout Editor")
|
|
* @var string
|
|
*/
|
|
public $showIn = 'both';
|
|
|
|
/**
|
|
* @SWG\Property(description="A flag indicating whether the module is assignable to a Layout")
|
|
* @var int
|
|
*/
|
|
public $assignable;
|
|
|
|
/**
|
|
* @SWG\Property(description="Does this module have a thumbnail to render?")
|
|
* @var int
|
|
*/
|
|
public $hasThumbnail;
|
|
|
|
/**
|
|
* @SWG\Property(description="This is the location to a module's thumbnail")
|
|
* @var string
|
|
*/
|
|
public $thumbnail;
|
|
|
|
/** @var int The width of the zone */
|
|
public $startWidth;
|
|
|
|
/** @var int The height of the zone */
|
|
public $startHeight;
|
|
|
|
/**
|
|
* @SWG\Property(description="Should be rendered natively by the Player or via the CMS (native|html)")
|
|
* @var string
|
|
*/
|
|
public $renderAs;
|
|
|
|
/**
|
|
* @SWG\Property(description="Class Name including namespace")
|
|
* @var string
|
|
*/
|
|
public $class;
|
|
|
|
/**
|
|
* @SWG\Property(description="Validator class name including namespace")
|
|
* @var string[]
|
|
*/
|
|
public $validatorClass = [];
|
|
|
|
/** @var \Xibo\Widget\Definition\Stencil|null Stencil for this modules preview */
|
|
public $preview;
|
|
|
|
/** @var \Xibo\Widget\Definition\Stencil|null Stencil for this modules HTML cache */
|
|
public $stencil;
|
|
|
|
/**
|
|
* @SWG\Property(description="Properties to display in the property panel and supply to stencils")
|
|
* @var \Xibo\Widget\Definition\Property[]|null
|
|
*/
|
|
public $properties;
|
|
|
|
/** @var \Xibo\Widget\Definition\Asset[]|null */
|
|
public $assets;
|
|
|
|
/**
|
|
* @SWG\Property(description="JavaScript function run when a module is initialised, before data is returned")
|
|
* @var string
|
|
*/
|
|
public $onInitialize;
|
|
|
|
/**
|
|
* @SWG\Property(description="Data Parser run against each data item applicable when a dataType is present")
|
|
* @var string
|
|
*/
|
|
public $onParseData;
|
|
|
|
/**
|
|
* @SWG\Property(description="A load function to run when the widget first fetches data")
|
|
* @var string
|
|
*/
|
|
public $onDataLoad;
|
|
|
|
/**
|
|
* @SWG\Property(description="JavaScript function run when a module is rendered, after data has been returned")
|
|
* @var string
|
|
*/
|
|
public $onRender;
|
|
|
|
/**
|
|
* @SWG\Property(description="JavaScript function run when a module becomes visible")
|
|
* @var string
|
|
*/
|
|
public $onVisible;
|
|
|
|
/**
|
|
* @SWG\Property(description="Optional sample data item, only applicable when a dataType is present")
|
|
* @var string
|
|
*/
|
|
public $sampleData;
|
|
|
|
// <editor-fold desc="Properties recorded in the database">
|
|
|
|
/**
|
|
* @SWG\Property(description="A flag indicating whether this module is enabled")
|
|
* @var int
|
|
*/
|
|
public $enabled;
|
|
|
|
/**
|
|
* @SWG\Property(description="A flag indicating whether the Layout designer should render a preview of this module")
|
|
* @var int
|
|
*/
|
|
public $previewEnabled;
|
|
|
|
/**
|
|
* @SWG\Property(
|
|
* description="The default duration for Widgets of this Module when the user has not set a duration."
|
|
* )
|
|
* @var int
|
|
*/
|
|
public $defaultDuration;
|
|
|
|
/**
|
|
* @SWG\Property(description="An array of additional module specific settings")
|
|
* @var \Xibo\Widget\Definition\Property[]
|
|
*/
|
|
public $settings = [];
|
|
|
|
/**
|
|
* @SWG\Property(description="An array of additional module specific group properties")
|
|
* @var \Xibo\Widget\Definition\PropertyGroup[]
|
|
*/
|
|
public $propertyGroups = [];
|
|
|
|
/**
|
|
* @SWG\Property(
|
|
* description="An array of required elements",
|
|
* type="array",
|
|
* @SWG\Items(type="string")
|
|
* )
|
|
* @var string[]
|
|
*/
|
|
public $requiredElements = [];
|
|
|
|
/**
|
|
* @SWG\Property()
|
|
* @var bool $isInstalled Is this module installed?
|
|
*/
|
|
public $isInstalled;
|
|
|
|
/**
|
|
* @SWG\Property()
|
|
* @var bool $isError Does this module have any errors?
|
|
*/
|
|
public $isError;
|
|
|
|
/**
|
|
* @SWG\Property()
|
|
* @var string[] $errors An array of errors this module has.
|
|
*/
|
|
public $errors;
|
|
|
|
// </editor-fold>
|
|
public $allowPreview;
|
|
|
|
/** @var ModuleFactory */
|
|
private $moduleFactory;
|
|
|
|
/** @var WidgetProviderInterface */
|
|
private $widgetProvider;
|
|
|
|
/** @var WidgetCompatibilityInterface */
|
|
private $widgetCompatibility;
|
|
|
|
/** @var WidgetValidatorInterface[] */
|
|
private $widgetValidators = [];
|
|
|
|
/**
|
|
* Entity constructor.
|
|
* @param StorageServiceInterface $store
|
|
* @param LogServiceInterface $log
|
|
* @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher
|
|
* @param \Xibo\Factory\ModuleFactory $moduleFactory
|
|
*/
|
|
public function __construct(
|
|
StorageServiceInterface $store,
|
|
LogServiceInterface $log,
|
|
EventDispatcherInterface $dispatcher,
|
|
ModuleFactory $moduleFactory
|
|
) {
|
|
$this->setCommonDependencies($store, $log, $dispatcher);
|
|
$this->moduleFactory = $moduleFactory;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function __toString()
|
|
{
|
|
return sprintf('%s - %s', $this->type, $this->name);
|
|
}
|
|
|
|
/**
|
|
* Is a template expected?
|
|
* @return bool
|
|
*/
|
|
public function isTemplateExpected(): bool
|
|
{
|
|
return (!empty($this->dataType));
|
|
}
|
|
|
|
/**
|
|
* Is a template expected?
|
|
* @return bool
|
|
*/
|
|
public function isDataProviderExpected(): bool
|
|
{
|
|
return (!empty($this->dataType));
|
|
}
|
|
|
|
/**
|
|
* Does this module have required elements?
|
|
* @return bool
|
|
*/
|
|
public function hasRequiredElements(): bool
|
|
{
|
|
return count($this->requiredElements) > 0;
|
|
}
|
|
|
|
/**
|
|
* Get this module's widget provider, or null if there isn't one
|
|
* @return \Xibo\Widget\Provider\WidgetProviderInterface|null
|
|
*/
|
|
public function getWidgetProviderOrNull(): ?WidgetProviderInterface
|
|
{
|
|
return $this->widgetProvider;
|
|
}
|
|
|
|
/**
|
|
* @param \Xibo\Entity\Widget $widget
|
|
* @return \Xibo\Widget\Provider\DataProvider
|
|
*/
|
|
public function createDataProvider(Widget $widget): DataProvider
|
|
{
|
|
return $this->moduleFactory->createDataProvider($this, $widget);
|
|
}
|
|
|
|
/**
|
|
* Fetch duration of a file.
|
|
* @param string $file
|
|
* @return int
|
|
*/
|
|
public function fetchDurationOrDefaultFromFile(string $file): int
|
|
{
|
|
$this->getLog()->debug('fetchDurationOrDefaultFromFile: fetchDuration with file: ' . $file);
|
|
|
|
// If we don't have a file name, then we use the default duration of 0 (end-detect)
|
|
if (empty($file)) {
|
|
return 0;
|
|
} else {
|
|
$info = new \getID3();
|
|
$file = $info->analyze($file);
|
|
|
|
// Log error if duration is missing
|
|
if (!isset($file['playtime_seconds'])) {
|
|
$errorMessage = isset($file['error'])
|
|
? implode('; ', $file['error'])
|
|
: 'Unknown';
|
|
$this->getLog()->error('fetchDurationOrDefaultFromFile; Missing playtime_seconds in analyzed
|
|
file. Error: ' . $errorMessage);
|
|
}
|
|
|
|
return intval($file['playtime_seconds'] ?? $this->defaultDuration);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate the duration of this Widget.
|
|
* @param Widget $widget
|
|
* @return int|null
|
|
*/
|
|
public function calculateDuration(Widget $widget): ?int
|
|
{
|
|
if ($this->widgetProvider === null && $this->regionSpecific === 1) {
|
|
// Take some default action to cover the majourity of region specific widgets
|
|
// Duration can depend on the number of items per page for some widgets
|
|
// this is a legacy way of working, and our preference is to use elements
|
|
$numItems = $widget->getOptionValue('numItems', 15);
|
|
|
|
if ($widget->getOptionValue('durationIsPerItem', 0) == 1 && $numItems > 1) {
|
|
// If we have paging involved then work out the page count.
|
|
$itemsPerPage = $widget->getOptionValue('itemsPerPage', 0);
|
|
if ($itemsPerPage > 0) {
|
|
$numItems = ceil($numItems / $itemsPerPage);
|
|
}
|
|
|
|
return $widget->calculatedDuration * $numItems;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else if ($this->widgetProvider === null) {
|
|
return null;
|
|
}
|
|
|
|
$this->getLog()->debug('calculateDuration: using widget provider');
|
|
|
|
$durationProvider = $this->moduleFactory->createDurationProvider($this, $widget);
|
|
$this->widgetProvider->fetchDuration($durationProvider);
|
|
|
|
return $durationProvider->isDurationSet() ? $durationProvider->getDuration() : null;
|
|
}
|
|
|
|
/**
|
|
* Sets the widget provider for this module
|
|
* @param \Xibo\Widget\Provider\WidgetProviderInterface $widgetProvider
|
|
* @return $this
|
|
*/
|
|
public function setWidgetProvider(WidgetProviderInterface $widgetProvider): Module
|
|
{
|
|
$this->widgetProvider = $widgetProvider;
|
|
$this->widgetProvider
|
|
->setLog($this->getLog()->getLoggerInterface())
|
|
->setDispatcher($this->getDispatcher());
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Is a widget compatibility available
|
|
* @return bool
|
|
*/
|
|
public function isWidgetCompatibilityAvailable(): bool
|
|
{
|
|
return $this->widgetCompatibility !== null;
|
|
}
|
|
|
|
/**
|
|
* Get this module's widget compatibility, or null if there isn't one
|
|
* @return \Xibo\Widget\Provider\WidgetCompatibilityInterface|null
|
|
*/
|
|
public function getWidgetCompatibilityOrNull(): ?WidgetCompatibilityInterface
|
|
{
|
|
return $this->widgetCompatibility;
|
|
}
|
|
|
|
/**
|
|
* Sets the widget compatibility for this module
|
|
* @param WidgetCompatibilityInterface $widgetCompatibility
|
|
* @return $this
|
|
*/
|
|
public function setWidgetCompatibility(WidgetCompatibilityInterface $widgetCompatibility): Module
|
|
{
|
|
$this->widgetCompatibility = $widgetCompatibility;
|
|
$this->widgetCompatibility->setLog($this->getLog()->getLoggerInterface());
|
|
return $this;
|
|
}
|
|
|
|
public function addWidgetValidator(WidgetValidatorInterface $widgetValidator): Module
|
|
{
|
|
$this->widgetValidators[] = $widgetValidator;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get this module's widget validators
|
|
* @return \Xibo\Widget\Provider\WidgetValidatorInterface[]
|
|
*/
|
|
public function getWidgetValidators(): array
|
|
{
|
|
return $this->widgetValidators;
|
|
}
|
|
|
|
/**
|
|
* Get all properties which allow library references.
|
|
* @return \Xibo\Widget\Definition\Property[]
|
|
*/
|
|
public function getPropertiesAllowingLibraryRefs(): array
|
|
{
|
|
$props = [];
|
|
foreach ($this->properties as $property) {
|
|
if ($property->allowLibraryRefs) {
|
|
$props[] = $property;
|
|
}
|
|
}
|
|
|
|
return $props;
|
|
}
|
|
|
|
/**
|
|
* Get assets
|
|
* @return \Xibo\Widget\Definition\Asset[]
|
|
*/
|
|
public function getAssets(): array
|
|
{
|
|
return $this->assets;
|
|
}
|
|
|
|
/**
|
|
* Get a module setting
|
|
* If the setting does not exist, $default will be returned.
|
|
* If the setting exists, but is not set, the default value from the setting will be returned
|
|
* @param string $setting The setting
|
|
* @param mixed|null $default A default value if the setting does not exist
|
|
* @return mixed
|
|
*/
|
|
public function getSetting(string $setting, $default = null)
|
|
{
|
|
foreach ($this->settings as $property) {
|
|
if ($property->id === $setting) {
|
|
return $property->value ?? $property->default;
|
|
}
|
|
}
|
|
|
|
return $default;
|
|
}
|
|
|
|
/**
|
|
* @throws \Xibo\Support\Exception\InvalidArgumentException
|
|
*/
|
|
public function validate()
|
|
{
|
|
if (!v::intType()->validate($this->defaultDuration)) {
|
|
throw new InvalidArgumentException(__('Default Duration is a required field.'), 'defaultDuration');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @throws \Xibo\Support\Exception\InvalidArgumentException
|
|
*/
|
|
public function save()
|
|
{
|
|
$this->validate();
|
|
|
|
if (!$this->isInstalled) {
|
|
$this->add();
|
|
} else {
|
|
$this->edit();
|
|
}
|
|
}
|
|
|
|
private function add()
|
|
{
|
|
$this->moduleId = $this->getStore()->insert('
|
|
INSERT INTO `module` (
|
|
`moduleId`,
|
|
`enabled`,
|
|
`previewEnabled`,
|
|
`defaultDuration`,
|
|
`settings`
|
|
)
|
|
VALUES (
|
|
:moduleId,
|
|
:enabled,
|
|
:previewEnabled,
|
|
:defaultDuration,
|
|
:settings
|
|
)
|
|
', [
|
|
'moduleId' => $this->moduleId,
|
|
'enabled' => $this->enabled,
|
|
'previewEnabled' => $this->previewEnabled,
|
|
'defaultDuration' => $this->defaultDuration,
|
|
'settings' => $this->getSettingsForSaving()
|
|
]);
|
|
}
|
|
|
|
private function edit()
|
|
{
|
|
$this->getStore()->update('
|
|
UPDATE `module` SET
|
|
enabled = :enabled,
|
|
previewEnabled = :previewEnabled,
|
|
defaultDuration = :defaultDuration,
|
|
settings = :settings
|
|
WHERE moduleid = :moduleId
|
|
', [
|
|
'moduleId' => $this->moduleId,
|
|
'enabled' => $this->enabled,
|
|
'previewEnabled' => $this->previewEnabled,
|
|
'defaultDuration' => $this->defaultDuration,
|
|
'settings' => $this->getSettingsForSaving()
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
private function getSettingsForSaving(): string
|
|
{
|
|
$settings = [];
|
|
foreach ($this->settings as $setting) {
|
|
if ($setting->value !== null) {
|
|
$settings[$setting->id] = $setting->value;
|
|
}
|
|
}
|
|
return count($settings) > 0 ? json_encode($settings) : '[]';
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getSettingsForOutput(): array
|
|
{
|
|
$settings = [];
|
|
foreach ($this->settings as $setting) {
|
|
$settings[$setting->id] = $setting->value ?? $setting->default;
|
|
}
|
|
return $settings;
|
|
}
|
|
|
|
/**
|
|
* Delete this module
|
|
* @return void
|
|
*/
|
|
public function delete()
|
|
{
|
|
$this->getStore()->update('DELETE FROM `module` WHERE moduleId = :id', [
|
|
'id' => $this->moduleId
|
|
]);
|
|
}
|
|
}
|