699 lines
25 KiB
PHP
699 lines
25 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\Controller;
|
|
|
|
use Psr\Http\Message\ResponseInterface;
|
|
use Slim\Http\Response as Response;
|
|
use Slim\Http\ServerRequest as Request;
|
|
use Xibo\Factory\ModuleFactory;
|
|
use Xibo\Factory\ModuleTemplateFactory;
|
|
use Xibo\Helper\SendFile;
|
|
use Xibo\Service\MediaService;
|
|
use Xibo\Service\UploadService;
|
|
use Xibo\Support\Exception\AccessDeniedException;
|
|
use Xibo\Support\Exception\ConfigurationException;
|
|
use Xibo\Support\Exception\ControllerNotImplemented;
|
|
use Xibo\Support\Exception\GeneralException;
|
|
use Xibo\Support\Exception\InvalidArgumentException;
|
|
use Xibo\Support\Exception\NotFoundException;
|
|
|
|
/**
|
|
* Class Module
|
|
* @package Xibo\Controller
|
|
*/
|
|
class Developer extends Base
|
|
{
|
|
public function __construct(
|
|
private readonly ModuleFactory $moduleFactory,
|
|
private readonly ModuleTemplateFactory $moduleTemplateFactory
|
|
) {
|
|
}
|
|
|
|
/**
|
|
* Display the module templates page
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @return \Slim\Http\Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function displayTemplatePage(Request $request, Response $response): Response
|
|
{
|
|
$this->getState()->template = 'developer-template-page';
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Show Module templates in a grid
|
|
* @param \Slim\Http\ServerRequest $request
|
|
* @param \Slim\Http\Response $response
|
|
* @return \Slim\Http\Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function templateGrid(Request $request, Response $response): Response
|
|
{
|
|
$params = $this->getSanitizer($request->getParams());
|
|
|
|
$templates = $this->moduleTemplateFactory->loadUserTemplates(
|
|
$this->gridRenderSort($params),
|
|
$this->gridRenderFilter(
|
|
[
|
|
'id' => $params->getInt('id'),
|
|
'templateId' => $params->getString('templateId'),
|
|
'dataType' => $params->getString('dataType'),
|
|
],
|
|
$params
|
|
)
|
|
);
|
|
|
|
foreach ($templates as $template) {
|
|
if ($this->isApi($request)) {
|
|
break;
|
|
}
|
|
|
|
$template->includeProperty('buttons');
|
|
|
|
if ($this->getUser()->checkEditable($template) &&
|
|
$this->getUser()->featureEnabled('developer.edit')
|
|
) {
|
|
// Edit button
|
|
$template->buttons[] = [
|
|
'id' => 'template_button_edit',
|
|
'url' => $this->urlFor($request, 'developer.templates.view.edit', ['id' => $template->id]),
|
|
'text' => __('Edit'),
|
|
'class' => 'XiboRedirectButton',
|
|
];
|
|
|
|
$template->buttons[] = [
|
|
'id' => 'template_button_export',
|
|
'linkType' => '_self', 'external' => true,
|
|
'url' => $this->urlFor($request, 'developer.templates.export', ['id' => $template->id]),
|
|
'text' => __('Export XML'),
|
|
];
|
|
|
|
$template->buttons[] = [
|
|
'id' => 'template_button_copy',
|
|
'url' => $this->urlFor($request, 'developer.templates.form.copy', ['id' => $template->id]),
|
|
'text' => __('Copy'),
|
|
];
|
|
}
|
|
|
|
if ($this->getUser()->featureEnabled('developer.edit') &&
|
|
$this->getUser()->checkPermissionsModifyable($template)
|
|
) {
|
|
$template->buttons[] = ['divider' => true];
|
|
// Permissions for Module Template
|
|
$template->buttons[] = [
|
|
'id' => 'template_button_permissions',
|
|
'url' => $this->urlFor(
|
|
$request,
|
|
'user.permissions.form',
|
|
['entity' => 'ModuleTemplate', 'id' => $template->id]
|
|
),
|
|
'text' => __('Share'),
|
|
'multi-select' => true,
|
|
'dataAttributes' => [
|
|
[
|
|
'name' => 'commit-url',
|
|
'value' => $this->urlFor(
|
|
$request,
|
|
'user.permissions.multi',
|
|
['entity' => 'ModuleTemplate', 'id' => $template->id]
|
|
)
|
|
],
|
|
['name' => 'commit-method', 'value' => 'post'],
|
|
['name' => 'id', 'value' => 'template_button_permissions'],
|
|
['name' => 'text', 'value' => __('Share')],
|
|
['name' => 'rowtitle', 'value' => $template->templateId],
|
|
['name' => 'sort-group', 'value' => 2],
|
|
['name' => 'custom-handler', 'value' => 'XiboMultiSelectPermissionsFormOpen'],
|
|
[
|
|
'name' => 'custom-handler-url',
|
|
'value' => $this->urlFor(
|
|
$request,
|
|
'user.permissions.multi.form',
|
|
['entity' => 'ModuleTemplate']
|
|
)
|
|
],
|
|
['name' => 'content-id-name', 'value' => 'id']
|
|
]
|
|
];
|
|
}
|
|
|
|
if ($this->getUser()->checkDeleteable($template) &&
|
|
$this->getUser()->featureEnabled('developer.delete')
|
|
) {
|
|
$template->buttons[] = ['divider' => true];
|
|
// Delete button
|
|
$template->buttons[] = [
|
|
'id' => 'template_button_delete',
|
|
'url' => $this->urlFor($request, 'developer.templates.form.delete', ['id' => $template->id]),
|
|
'text' => __('Delete'),
|
|
'multi-select' => true,
|
|
'dataAttributes' => [
|
|
[
|
|
'name' => 'commit-url',
|
|
'value' => $this->urlFor(
|
|
$request,
|
|
'developer.templates.delete',
|
|
['id' => $template->id]
|
|
)
|
|
],
|
|
['name' => 'commit-method', 'value' => 'delete'],
|
|
['name' => 'id', 'value' => 'template_button_delete'],
|
|
['name' => 'text', 'value' => __('Delete')],
|
|
['name' => 'sort-group', 'value' => 1],
|
|
['name' => 'rowtitle', 'value' => $template->templateId]
|
|
]
|
|
];
|
|
}
|
|
}
|
|
|
|
$this->getState()->template = 'grid';
|
|
$this->getState()->recordsTotal = $this->moduleTemplateFactory->countLast();
|
|
$this->getState()->setData($templates);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Shows an add form for a module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @return \Slim\Http\Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function templateAddForm(Request $request, Response $response): Response
|
|
{
|
|
$this->getState()->template = 'developer-template-form-add';
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Display the module template page
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param mixed $id The template ID to edit.
|
|
* @return \Slim\Http\Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function displayTemplateEditPage(Request $request, Response $response, $id): Response
|
|
{
|
|
$template = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
if ($template->ownership !== 'user') {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$this->getState()->template = 'developer-template-edit-page';
|
|
$this->getState()->setData([
|
|
'template' => $template,
|
|
'propertiesJSON' => json_encode($template->properties),
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Add a module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @return \Slim\Http\Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function templateAdd(Request $request, Response $response): Response
|
|
{
|
|
// When adding a template we just save the XML
|
|
$params = $this->getSanitizer($request->getParams());
|
|
|
|
$templateId = $params->getString('templateId', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a unique template ID'), 'templateId');
|
|
}]);
|
|
$title = $params->getString('title', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a title'), 'title');
|
|
}]);
|
|
$dataType = $params->getString('dataType', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a data type'), 'dataType');
|
|
}]);
|
|
$showIn = $params->getString('showIn', ['throw' => function () {
|
|
throw new InvalidArgumentException(
|
|
__('Please select relevant editor which should show this Template'),
|
|
'showIn'
|
|
);
|
|
}]);
|
|
|
|
// do we have a template selected?
|
|
if (!empty($params->getString('copyTemplateId'))) {
|
|
// get the selected template
|
|
$copyTemplate = $this->moduleTemplateFactory->getByDataTypeAndId(
|
|
$dataType,
|
|
$params->getString('copyTemplateId')
|
|
);
|
|
|
|
// get the template xml and load to document.
|
|
$xml = new \DOMDocument();
|
|
$xml->loadXML($copyTemplate->getXml());
|
|
|
|
// get template node, make adjustments from the form
|
|
$templateNode = $xml->getElementsByTagName('template')[0];
|
|
$this->setNode($xml, 'id', $templateId, false, $templateNode);
|
|
$this->setNode($xml, 'title', $title, false, $templateNode);
|
|
$this->setNode($xml, 'showIn', $showIn, false, $templateNode);
|
|
|
|
// create template with updated xml.
|
|
$template = $this->moduleTemplateFactory->createUserTemplate($xml->saveXML());
|
|
} else {
|
|
// The most basic template possible.
|
|
$template = $this->moduleTemplateFactory->createUserTemplate('<?xml version="1.0"?>
|
|
<template>
|
|
<id>' . $templateId . '</id>
|
|
<title>' . $title . '</title>
|
|
<type>static</type>
|
|
<dataType>' . $dataType . '</dataType>
|
|
<showIn>'. $showIn . '</showIn>
|
|
<properties></properties>
|
|
</template>');
|
|
}
|
|
|
|
$template->ownerId = $this->getUser()->userId;
|
|
$template->save();
|
|
|
|
$this->getState()->hydrate([
|
|
'httpState' => 201,
|
|
'message' => __('Added'),
|
|
'id' => $template->id,
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Edit a module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return Response
|
|
* @throws \Xibo\Support\Exception\GeneralException
|
|
*/
|
|
public function templateEdit(Request $request, Response $response, $id): Response
|
|
{
|
|
$template = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
$params = $this->getSanitizer($request->getParams());
|
|
$templateId = $params->getString('templateId', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a unique template ID'), 'templateId');
|
|
}]);
|
|
$title = $params->getString('title', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a title'), 'title');
|
|
}]);
|
|
$dataType = $params->getString('dataType', ['throw' => function () {
|
|
throw new InvalidArgumentException(__('Please supply a data type'), 'dataType');
|
|
}]);
|
|
$showIn = $params->getString('showIn', ['throw' => function () {
|
|
throw new InvalidArgumentException(
|
|
__('Please select relevant editor which should show this Template'),
|
|
'showIn'
|
|
);
|
|
}]);
|
|
|
|
$template->dataType = $dataType;
|
|
$template->isEnabled = $params->getCheckbox('enabled');
|
|
|
|
// TODO: validate?
|
|
$twig = $params->getParam('twig');
|
|
$hbs = $params->getParam('hbs');
|
|
$style = $params->getParam('style');
|
|
$head = $params->getParam('head');
|
|
$properties = $params->getParam('properties');
|
|
$onTemplateRender = $params->getParam('onTemplateRender');
|
|
$onTemplateVisible = $params->getParam('onTemplateVisible');
|
|
|
|
// We need to edit the XML we have for this template.
|
|
$document = $template->getDocument();
|
|
|
|
// Root nodes
|
|
$template->templateId = $templateId;
|
|
$this->setNode($document, 'id', $templateId, false);
|
|
$this->setNode($document, 'title', $title, false);
|
|
$this->setNode($document, 'showIn', $showIn, false);
|
|
$this->setNode($document, 'dataType', $dataType, false);
|
|
$this->setNode($document, 'onTemplateRender', $onTemplateRender);
|
|
$this->setNode($document, 'onTemplateVisible', $onTemplateVisible);
|
|
|
|
// Stencil nodes.
|
|
$stencilNodes = $document->getElementsByTagName('stencil');
|
|
if ($stencilNodes->count() <= 0) {
|
|
$stencilNode = $document->createElement('stencil');
|
|
$document->documentElement->appendChild($stencilNode);
|
|
} else {
|
|
$stencilNode = $stencilNodes[0];
|
|
}
|
|
|
|
$this->setNode($document, 'twig', $twig, true, $stencilNode);
|
|
$this->setNode($document, 'hbs', $hbs, true, $stencilNode);
|
|
$this->setNode($document, 'style', $style, true, $stencilNode);
|
|
$this->setNode($document, 'head', $head, true, $stencilNode);
|
|
|
|
// Properties.
|
|
// this is different because we want to replace the properties node with a new one.
|
|
if (!empty($properties)) {
|
|
// parse json and create a new properties node
|
|
$newPropertiesXml = $this->moduleTemplateFactory->parseJsonPropertiesToXml($properties);
|
|
|
|
$propertiesNodes = $document->getElementsByTagName('properties');
|
|
|
|
if ($propertiesNodes->count() <= 0) {
|
|
$document->documentElement->appendChild(
|
|
$document->importNode($newPropertiesXml->documentElement, true)
|
|
);
|
|
} else {
|
|
$document->documentElement->replaceChild(
|
|
$document->importNode($newPropertiesXml->documentElement, true),
|
|
$propertiesNodes[0]
|
|
);
|
|
}
|
|
}
|
|
|
|
// All done.
|
|
$template->setXml($document->saveXML());
|
|
$template->save();
|
|
|
|
if ($params->getCheckbox('isInvalidateWidget')) {
|
|
$template->invalidate();
|
|
}
|
|
|
|
$this->getState()->hydrate([
|
|
'message' => sprintf(__('Edited %s'), $template->title),
|
|
'id' => $template->id,
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Helper function to set a node.
|
|
* @param \DOMDocument $document
|
|
* @param string $node
|
|
* @param string $value
|
|
* @param bool $cdata
|
|
* @param \DOMElement|null $childNode
|
|
* @return void
|
|
* @throws \DOMException
|
|
*/
|
|
private function setNode(
|
|
\DOMDocument $document,
|
|
string $node,
|
|
string $value,
|
|
bool $cdata = true,
|
|
?\DOMElement $childNode = null
|
|
): void {
|
|
$addTo = $childNode ?? $document->documentElement;
|
|
|
|
$nodes = $addTo->getElementsByTagName($node);
|
|
if ($nodes->count() <= 0) {
|
|
if ($cdata) {
|
|
$element = $document->createElement($node);
|
|
$cdata = $document->createCDATASection($value);
|
|
$element->appendChild($cdata);
|
|
} else {
|
|
$element = $document->createElement($node, $value);
|
|
}
|
|
|
|
$addTo->appendChild($element);
|
|
} else {
|
|
/** @var \DOMElement $element */
|
|
$element = $nodes[0];
|
|
if ($cdata) {
|
|
$cdata = $document->createCDATASection($value);
|
|
$element->textContent = $value;
|
|
|
|
if ($element->firstChild !== null) {
|
|
$element->replaceChild($cdata, $element->firstChild);
|
|
} else {
|
|
//$element->textContent = '';
|
|
$element->appendChild($cdata);
|
|
}
|
|
} else {
|
|
$element->textContent = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getAvailableDataTypes(Request $request, Response $response)
|
|
{
|
|
$params = $this->getSanitizer($request->getParams());
|
|
$dataTypes = $this->moduleFactory->getAllDataTypes();
|
|
|
|
if ($params->getString('dataType') !== null) {
|
|
foreach ($dataTypes as $dataType) {
|
|
if ($dataType->id === $params->getString('dataType')) {
|
|
$dataTypes = [$dataType];
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->getState()->template = 'grid';
|
|
$this->getState()->recordsTotal = 0;
|
|
$this->getState()->setData($dataTypes);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Export module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return ResponseInterface|Response
|
|
* @throws AccessDeniedException
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws NotFoundException
|
|
*/
|
|
public function templateExport(Request $request, Response $response, $id): Response|ResponseInterface
|
|
{
|
|
$template = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
if ($template->ownership !== 'user') {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$tempFileName = $this->getConfig()->getSetting('LIBRARY_LOCATION') . 'temp/' . $template->templateId . '.xml';
|
|
|
|
$template->getDocument()->save($tempFileName);
|
|
|
|
$this->setNoOutput(true);
|
|
|
|
return $this->render($request, SendFile::decorateResponse(
|
|
$response,
|
|
$this->getConfig()->getSetting('SENDFILE_MODE'),
|
|
$tempFileName,
|
|
$template->templateId . '.xml'
|
|
)->withHeader('Content-Type', 'text/xml;charset=utf-8'));
|
|
}
|
|
|
|
/**
|
|
* Import xml file and create module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @return ResponseInterface|Response
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws ConfigurationException
|
|
*/
|
|
public function templateImport(Request $request, Response $response): Response|ResponseInterface
|
|
{
|
|
$this->getLog()->debug('Import Module Template');
|
|
|
|
$libraryFolder = $this->getConfig()->getSetting('LIBRARY_LOCATION');
|
|
|
|
// Make sure the library exists
|
|
MediaService::ensureLibraryExists($libraryFolder);
|
|
|
|
$options = [
|
|
'upload_dir' => $libraryFolder . 'temp/',
|
|
'accept_file_types' => '/\.xml/i',
|
|
'libraryQuotaFull' => false,
|
|
];
|
|
|
|
$this->getLog()->debug('Hand off to Upload Handler with options: ' . json_encode($options));
|
|
|
|
// Hand off to the Upload Handler provided by jquery-file-upload
|
|
$uploadService = new UploadService($libraryFolder . 'temp/', $options, $this->getLog(), $this->getState());
|
|
$uploadHandler = $uploadService->createUploadHandler();
|
|
|
|
$uploadHandler->setPostProcessor(function ($file, $uploadHandler) use ($libraryFolder) {
|
|
// Return right away if the file already has an error.
|
|
if (!empty($file->error)) {
|
|
return $file;
|
|
}
|
|
|
|
$this->getUser()->isQuotaFullByUser(true);
|
|
|
|
$filePath = $libraryFolder . 'temp/' . $file->fileName;
|
|
|
|
// load the xml from uploaded file
|
|
$xml = new \DOMDocument();
|
|
$xml->load($filePath);
|
|
|
|
// Add the Template
|
|
$moduleTemplate = $this->moduleTemplateFactory->createUserTemplate($xml->saveXML());
|
|
$moduleTemplate->ownerId = $this->getUser()->userId;
|
|
$moduleTemplate->save();
|
|
|
|
// Tidy up the temporary file
|
|
@unlink($filePath);
|
|
|
|
return $file;
|
|
});
|
|
|
|
$uploadHandler->post();
|
|
|
|
$this->setNoOutput(true);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Show module template copy form
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return Response|ResponseInterface
|
|
* @throws AccessDeniedException
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws InvalidArgumentException
|
|
* @throws NotFoundException
|
|
*/
|
|
public function templateCopyForm(Request $request, Response $response, $id): Response|ResponseInterface
|
|
{
|
|
$moduleTemplate = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
if (!$this->getUser()->checkViewable($moduleTemplate)) {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$this->getState()->template = 'developer-template-form-copy';
|
|
$this->getState()->setData([
|
|
'template' => $moduleTemplate,
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Copy module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return Response|ResponseInterface
|
|
* @throws AccessDeniedException
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws InvalidArgumentException
|
|
* @throws NotFoundException
|
|
*/
|
|
public function templateCopy(Request $request, Response $response, $id): Response|ResponseInterface
|
|
{
|
|
$moduleTemplate = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
if (!$this->getUser()->checkViewable($moduleTemplate)) {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$params = $this->getSanitizer($request->getParams());
|
|
|
|
$newTemplate = clone $moduleTemplate;
|
|
$newTemplate->templateId = $params->getString('templateId');
|
|
$newTemplate->save();
|
|
|
|
// Return
|
|
$this->getState()->hydrate([
|
|
'httpStatus' => 201,
|
|
'message' => sprintf(__('Copied as %s'), $newTemplate->templateId),
|
|
'id' => $newTemplate->id,
|
|
'data' => $newTemplate
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Show module template delete form
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return Response|ResponseInterface
|
|
* @throws AccessDeniedException
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws InvalidArgumentException
|
|
* @throws NotFoundException
|
|
*/
|
|
public function templateDeleteForm(Request $request, Response $response, $id): Response|ResponseInterface
|
|
{
|
|
$moduleTemplate = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
if (!$this->getUser()->checkDeleteable($moduleTemplate)) {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$this->getState()->template = 'developer-template-form-delete';
|
|
$this->getState()->setData([
|
|
'template' => $moduleTemplate,
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
|
|
/**
|
|
* Delete module template
|
|
* @param Request $request
|
|
* @param Response $response
|
|
* @param $id
|
|
* @return Response|ResponseInterface
|
|
* @throws AccessDeniedException
|
|
* @throws ControllerNotImplemented
|
|
* @throws GeneralException
|
|
* @throws InvalidArgumentException
|
|
* @throws NotFoundException
|
|
*/
|
|
public function templateDelete(Request $request, Response $response, $id): Response|ResponseInterface
|
|
{
|
|
$moduleTemplate = $this->moduleTemplateFactory->getUserTemplateById($id);
|
|
|
|
if (!$this->getUser()->checkDeleteable($moduleTemplate)) {
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
$moduleTemplate->delete();
|
|
|
|
// Return
|
|
$this->getState()->hydrate([
|
|
'httpStatus' => 204,
|
|
'message' => sprintf(__('Deleted %s'), $moduleTemplate->templateId)
|
|
]);
|
|
|
|
return $this->render($request, $response);
|
|
}
|
|
}
|