~xibo-maintainers/xibo/tempel

use Intervention\Image\ImageManagerStatic as Img;

use Mimey\MimeTypes;

use Stash\Interfaces\PoolInterface;

use Stash\Invalidation;

use Stash\Item;

use Symfony\Component\EventDispatcher\EventDispatcherInterface;

use Xibo\Entity\Media;

use Xibo\Exception\InvalidArgumentException;

use Xibo\Exception\XiboException;

use Xibo\Factory\CommandFactory;

use Xibo\Factory\DataSetColumnFactory;

use Xibo\Factory\DataSetFactory;

use Xibo\Factory\DisplayFactory;

use Xibo\Factory\DisplayGroupFactory;

use Xibo\Factory\LayoutFactory;

use Xibo\Factory\ModuleFactory;

use Xibo\Factory\PermissionFactory;

use Xibo\Factory\ScheduleFactory;

use Xibo\Factory\UserGroupFactory;

use Xibo\Factory\WidgetFactory;

use Xibo\Service\ConfigServiceInterface;

use Xibo\Service\DateServiceInterface;

use Xibo\Service\LogServiceInterface;

use Xibo\Service\SanitizerServiceInterface;

use Xibo\Storage\StorageServiceInterface;

    private $app;

     * @var string A module populated status message set during isValid.

     */

    protected $statusMessage;

 

    /** @var string|null Cache Key Prefix */

    private $cacheKeyPrefix = null;

 

    //

    // Injected Factory Classes and Services Follow

    //

 

    /**

     * @var StorageServiceInterface

     */

    private $store;

 

    /**

     * @var PoolInterface

     */

    private $pool;

 

    /**

     * @var LogServiceInterface

     */

    private $logService;

 

    /**

     * @var ConfigServiceInterface

     */

    private $configService;

 

    /**

     * @var DateServiceInterface

     */

    private $dateService;

 

    /**

     * @var SanitizerServiceInterface

     */

    private $sanitizerService;

 

    /** @var  EventDispatcherInterface */

    private $dispatcher;

 

    /** @var ModuleFactory  */

    protected $moduleFactory;

 

    /**

     * @var MediaFactory

     */

    protected $mediaFactory;

 

    /**

     * @var DataSetFactory

     */

    protected $dataSetFactory;

 

    /**

     * @var DataSetColumnFactory

     */

    protected $dataSetColumnFactory;

 

    /**

     * @var TransitionFactory

     */

    protected $transitionFactory;

 

    /**

     * @var DisplayFactory

     */

    protected $displayFactory;

 

    /**

     * @var CommandFactory

     */

    protected $commandFactory;

 

    /** @var  LayoutFactory */

    protected $layoutFactory;

 

    /** @var  WidgetFactory */

    protected $widgetFactory;

 

    /** @var  DisplayGroupFactory */

    protected $displayGroupFactory;

 

    /** @var  ScheduleFactory */

    protected $scheduleFactory;

 

    /** @var  PermissionFactory */

    protected $permissionFactory;

 

    /** @var  UserGroupFactory */

    protected $userGroupFactory;

 

    /**

     * ModuleWidget constructor.

     * @param Slim $app

     * @param StorageServiceInterface $store

     * @param PoolInterface $pool

     * @param LogServiceInterface $log

     * @param ConfigServiceInterface $config

     * @param DateServiceInterface $date

     * @param SanitizerServiceInterface $sanitizer

     * @param EventDispatcherInterface $dispatcher

     * @param ModuleFactory $moduleFactory

     * @param MediaFactory $mediaFactory

     * @param DataSetFactory $dataSetFactory

     * @param DataSetColumnFactory $dataSetColumnFactory

     * @param TransitionFactory $transitionFactory

     * @param DisplayFactory $displayFactory

     * @param CommandFactory $commandFactory

     * @param ScheduleFactory $scheduleFactory

     * @param PermissionFactory $permissionFactory

     * @param UserGroupFactory $userGroupFactory

     */

    public function __construct($app, $store, $pool, $log, $config, $date, $sanitizer, $dispatcher, $moduleFactory, $mediaFactory, $dataSetFactory, $dataSetColumnFactory, $transitionFactory, $displayFactory, $commandFactory, $scheduleFactory, $permissionFactory, $userGroupFactory)

    {

        $this->app = $app;

        $this->store = $store;

        $this->pool = $pool;

        $this->logService = $log;

        $this->configService = $config;

        $this->dateService = $date;

        $this->sanitizerService = $sanitizer;

        $this->dispatcher = $dispatcher;

 

        $this->moduleFactory = $moduleFactory;

        $this->mediaFactory = $mediaFactory;

        $this->dataSetFactory = $dataSetFactory;

        $this->dataSetColumnFactory = $dataSetColumnFactory;

        $this->transitionFactory = $transitionFactory;

        $this->displayFactory = $displayFactory;

        $this->commandFactory = $commandFactory;

        $this->scheduleFactory = $scheduleFactory;

        $this->permissionFactory = $permissionFactory;

        $this->userGroupFactory = $userGroupFactory;

 

        $this->init();

    }

 

    /**

     * Set Child Object Dependencies

     * @param LayoutFactory $layoutFactory

     * @param WidgetFactory $widgetFactory

     * @param DisplayGroupFactory $displayGroupFactory

     */

    public function setChildObjectDependencies($layoutFactory, $widgetFactory, $displayGroupFactory)

    {

        $this->layoutFactory = $layoutFactory;

        $this->widgetFactory = $widgetFactory;

        $this->displayGroupFactory = $displayGroupFactory;

        if ($this->app == null)

            throw new \RuntimeException(__('Module Widget Application not set'));

 

     * Get Cache Pool

     * @return \Stash\Interfaces\PoolInterface

     */

    protected function getPool()

    {

        return $this->pool;

    }

 

    /**

     * Get Store

     * @return StorageServiceInterface

     */

    protected function getStore()

    {

        return $this->store;

    }

 

    /**

     * Get Log

     * @return LogServiceInterface

     */

    protected function getLog()

    {

        return $this->logService;

    }

 

    /**

     * Get Config

     * @return ConfigServiceInterface

     */

    public function getConfig()

    {

        return $this->configService;

    }

 

    /**

     * Get Date

     * @return DateServiceInterface

     */

    protected function getDate()

    {

        return $this->dateService;

    }

 

    /**

     * Get Sanitizer

     * @return SanitizerServiceInterface

     */

    protected function getSanitizer()

    {

        return $this->sanitizerService;

    }

 

    /**

     * @inheritdoc

     */

    protected function getDispatcher()

    {

        return $this->dispatcher;

    }

 

    //

    // End of Injected Factories and Services

    //

 

    /**

     * Any initialisation code

     */

    public function init()

    {

 

    }

 

    /**

     * Make a cache key

     * @param $id

     * @return string

     */

    public function makeCacheKey($id)

    {

        return $this->getCacheKeyPrefix() . '/' . $id;

    }

 

    /**

     * Get the cache prefix, including the leading /

     * @return null|string

     */

    private function getCacheKeyPrefix()

    {

        if ($this->cacheKeyPrefix == null) {

            $className = get_class($this);

            $this->cacheKeyPrefix = '/widget/' . substr($className, strrpos($className, '\\') + 1);

        }

 

        return $this->cacheKeyPrefix;

    }

 

    /**

     * Dump the cache for this module

     */

    public function dumpCacheForModule()

    {

        $this->getPool()->deleteItem($this->getCacheKeyPrefix());

    }

 

    // <editor-fold desc="request locking">

 

    /** @var  Item */

    private $lock;

 

    /**

     * Hold a lock on concurrent requests

     *  blocks if the request is locked

     * @param string|null $key

     * @param int $ttl seconds

     * @param int $wait seconds

     * @param int $tries

     * @throws XiboException

     */

    public function concurrentRequestLock($key = null, $ttl = 900, $wait = 5, $tries = 100)

    {

        // If the key is null default to the widgetId

        if ($key === null)

            $key = $this->widget->widgetId;

 

        $this->lock = $this->getPool()->getItem('locks/widget/' . $key);

 

        // Set the invalidation method to simply return the value (not that we use it, but it gets us a miss on expiry)

        $this->lock->setInvalidationMethod(Invalidation::VALUE);

 

        // Get the lock

        // other requests will wait here until we're done, or we've timed out

        $this->lock->get();

 

        // Did we get a lock?

        // if we're a miss, then we're not already locked

        if ($this->lock->isMiss()) {

            // so lock now

            $this->lock->set(true);

            $this->lock->expiresAfter($ttl);

            $this->lock->save();

 

            //sleep(30);

        } else {

            // We are a hit - we must be locked

            $this->getLog()->debug('LOCK hit for ' . $key);

 

            // Try again?

            $tries--;

 

            if ($tries <= 0) {

                // We've waited long enough

                throw new XiboException('Concurrent record locked, time out.');

            } else {

                $this->getLog()->debug('Unable to get a lock, trying again. Remaining retries: ' . $tries);

 

                // Hang about waiting for the lock to be released.

                sleep($wait);

 

                // Recursive request (we've decremented the number of tries)

                $this->concurrentRequestLock($key, $ttl, $wait, $tries);

            }

        }

    }

 

    /**

     * Release a lock on concurrent requests

     */

    public function concurrentRequestRelease()

    {

        if ($this->lock !== null) {

            // Release lock

            $this->lock->set(false);

            $this->lock->expiresAfter(1); // Expire straight away

 

            $this->getPool()->saveDeferred($this->lock);

        }

    }

 

    // </editor-fold>

 

    /**

     * should only be used on media items that do not automatically assign new media from the feed

        $this->widget->clearCachedMedia();

        if ($options['real']) {

                $this->getLog()->error('Tried to get real duration from a widget without media. widgetId: %d', $this->getWidgetId());

        } else if ($this->widget->duration === null && $this->module !== null) {

            return $this->module->defaultDuration;

     * Gets the calculated duration of this widget

     * @return int

     */

    final public function getCalculatedDurationForGetResource()

    {

        return ($this->widget->useDuration == 0) ? $this->getModule()->defaultDuration : $this->widget->duration;

    }

 

    /**

        $this->setDuration($this->getSanitizer()->getInt('duration', $this->getDuration()));

        $this->setUseDuration($this->getSanitizer()->getCheckbox('useDuration'));

        $this->setOption('name', $this->getSanitizer()->getString('name'));

 

        $this->widget->save();

        $this->getLog()->debug('Media assigned: ' . count($this->widget->mediaIds));

            $media = $this->getMedia();

        return '<div style="text-align:center;"><img alt="' . $this->getModuleType() . ' thumbnail" src="' . $this->getConfig()->uri('img/' . $this->getModule()->imageUri) . '" /></div>';

        $output .= '<div class="preview-module-image"><img alt="' . __($this->module->name) . ' thumbnail" src="' . $this->getConfig()->uri('img/' . $this->module->imageUri) . '" /></div>';

     * @param string $tab

     * Get File URL

     * @param Media $file

     * @param string|null $type

     * @return string

     */

    protected function getFileUrl($file, $type = null)

    {

        $isPreview = ($this->getSanitizer()->getCheckbox('preview') == 1);

        $params = ['id' => $file->mediaId];

 

        if ($type !== null) {

            $params['type'] = $type;

        }

 

        if ($isPreview) {

            return $this->getApp()->urlFor('library.download', $params) . '?preview=1"';

        } else {

            $url = $file->storedAs;

        }

 

        return $url;

    }

 

    /**

     * @param string $uri The file name

     * @param string|null $type

    protected function getResourceUrl($uri, $type = null)

        $isPreview = ($this->getSanitizer()->getCheckbox('preview') == 1);

 

        // Local clients store all files in the root of the library

        $uri = basename($uri);

 

        if ($isPreview) {

            // Use the URI to get this media record

            try {

                $media = $this->mediaFactory->getByName($uri);

                $params = ['id' => $media->mediaId];

 

                if ($type !== null) {

                    $params['type'] = $type;

                }

 

                return $this->getApp()->urlFor('library.download', $params) . '?preview=1';

 

            } catch (NotFoundException $notFoundException) {

                $this->getLog()->info('Widget referencing a resource that doesnt exist: ' . $this->getModuleType() . ' for ' . $uri);

 

                // Return a URL which will 404

                return '/' . $uri;

            }

        }

     * @throws InvalidArgumentException

                throw new InvalidArgumentException(__('Unknown transition type'), 'type');

            $transition = $this->transitionFactory->getByCode($code);

            $this->getLog()->error('Transition not found with code %s.', $code);

     * @param ModuleFactory $moduleFactory

     * @throws ControllerNotImplemented

    public function installOrUpdate($moduleFactory)

        $this->getLog()->notice('Request to install module with name: ' . $this->module->name, 'module', 'InstallModule');

     * Module settings buttons to be displayed on the module admin page

     * @return array

     */

    public function settingsButtons()

    {

        return [];

    }

 

    /**

     * Configure any additional module routes

     *  these are available through the api and web portal

     */

    public function configureRoutes()

    {

 

    }

 

    /**

     * Count Library Media

     * @return int

     */

    public function countLibraryMedia()

    {

        return 0;

    }

 

    /**

        return $this->widget->getPrimaryMediaId();

        $media = $this->mediaFactory->getById($this->getMediaId());

        $media->setChildObjectDependencies($this->layoutFactory, $this->widgetFactory, $this->displayGroupFactory, $this->displayFactory, $this->scheduleFactory);

        return $media;

        $media = $this->mediaFactory->getById($this->getMediaId());

 

        $this->getLog()->debug('Download for mediaId ' . $media->mediaId);

 

        // Are we a preview or not?

        $isPreview = ($this->getSanitizer()->getCheckbox('preview') == 1);

 

        // The file path

        $libraryPath = $this->getConfig()->GetSetting('LIBRARY_LOCATION') . $media->storedAs;

 

        // Set the content length

        $headers = $this->getApp()->response()->headers();

        $headers->set('Content-Length', filesize($libraryPath));

 

        // Different behaviour depending on whether we are a preview or not.

        if ($isPreview) {

            // correctly grab the MIME type of the file we want to serve

            $mimeTypes = new MimeTypes();

            $ext = explode('.', $media->storedAs);

            $headers->set('Content-Type', $mimeTypes->getMimeType($ext[count($ext) - 1]));

        } else {

            // This widget is expected to output a file - usually this is for file based media

            // Get the name with library

            $attachmentName = $this->getSanitizer()->getString('attachment', $media->storedAs);

 

            // Issue some headers

            $this->getApp()->etag($media->md5);

            $this->getApp()->expires('+1 week');

 

            $headers->set('Content-Type', 'application/octet-stream');

            $headers->set('Content-Transfer-Encoding', 'Binary');

            $headers->set('Content-disposition', 'attachment; filename="' . $attachmentName . '"');

        }

 

        // Output the file

        if ($this->getConfig()->GetSetting('SENDFILE_MODE') == 'Apache') {

            // Send via Apache X-Sendfile header?

            $headers->set('X-Sendfile', $libraryPath);

        }

        else if ($this->getConfig()->GetSetting('SENDFILE_MODE') == 'Nginx') {

            // Send via Nginx X-Accel-Redirect?

            $headers->set('X-Accel-Redirect', '/download/' . $media->storedAs);

                $entry = $this->mediaFactory->getById($mediaId);

                $this->getLog()->info('Reference to Unknown mediaId %d', $mediaId);

     * Get templatesAvailable

     * @param bool $loadImage Should the image URL be loaded?

     * @return array

     */

    public function templatesAvailable($loadImage = true)

    {

        if (!isset($this->module->settings['templates'])) {

 

            $this->module->settings['templates'] = [];

 

            // Scan the folder for template files

            foreach (glob(PROJECT_ROOT . '/modules/' . $this->module->type . '/*.template.json') as $template) {

                // Read the contents, json_decode and add to the array

                $template = json_decode(file_get_contents($template), true);

 

                if (isset($template['image'])) {

                    $template['fileName'] = $template['image'];

 

                    if ($loadImage) {

                        // We ltrim this because the control is expecting a relative URL

                        $template['image'] = ltrim($this->getApp()->urlFor('module.getTemplateImage', ['type' => $this->module->type, 'templateId' => $template['id']]), '/');

                    }

                } else {

                    $template['fileName'] = '';

                    $template['image'] = '';

                }

 

                $this->module->settings['templates'][] = $template;

            }

        }

 

        return $this->module->settings['templates'];

    }

 

    /**

     * Get by Template Id

     * @param int $templateId

     * @return array|null

     */

    public function getTemplateById($templateId)

    {

        $templates = $this->templatesAvailable(false);

        $template = null;

 

        if (count($templates) <= 0)

            return null;

 

        foreach ($templates as $item) {

            if ($item['id'] == $templateId) {

                $template = $item;

                break;

            }

        }

 

        return $template;

    }

 

    /**

     * Download an image for this template

     * @param int $templateId

     * @throws NotFoundException

     */

    public function getTemplateImage($templateId)

    {

        $template = $this->getTemplateById($templateId);

 

        if ($template === null || !isset($template['fileName']) || $template['fileName'] == '')

            throw new NotFoundException();

 

        // Output the image associated with this template

        echo Img::make(PROJECT_ROOT . '/' . $template['fileName'])->response();

    }

 

    /**