393 lines
11 KiB
PHP
393 lines
11 KiB
PHP
<?php
|
|
namespace Cjel\TemplatesAide\Controller;
|
|
|
|
/***
|
|
*
|
|
* This file is part of the "Templates Aide" Extension for TYPO3 CMS.
|
|
*
|
|
* For the full copyright and license information, please read the
|
|
* LICENSE.txt file that was distributed with this source code.
|
|
*
|
|
* (c) 2021 Philipp Dieter <philippdieter@attic-media.net>
|
|
*
|
|
***/
|
|
|
|
use Cjel\TemplatesAide\Traits\FormatResultTrait;
|
|
use Cjel\TemplatesAide\Traits\ValidationTrait;
|
|
use Psr\Http\Message\ResponseInterface;
|
|
use Psr\Http\Message\ServerRequestInterface;
|
|
use TYPO3\CMS\Core\Cache\CacheManager;
|
|
use TYPO3\CMS\Core\Database\ConnectionPool;
|
|
use TYPO3\CMS\Core\Database\Query\Restriction\DefaultRestrictionContainer;
|
|
use TYPO3\CMS\Core\Localization\LanguageService;
|
|
use TYPO3\CMS\Core\Log\LogManager;
|
|
use TYPO3\CMS\Core\Utility\GeneralUtility;
|
|
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
|
|
use TYPO3\CMS\Extbase\Object\ObjectManager;
|
|
use TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapper;
|
|
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
|
|
use TYPO3\CMS\Extbase\Reflection\ClassSchema;
|
|
use TYPO3\CMS\Extbase\Reflection\ReflectionService;
|
|
use TYPO3\CMS\Frontend\Plugin\AbstractPlugin;
|
|
use TYPO3\CMS\Frontend\Utility\EidUtility;
|
|
|
|
use TYPO3\CMS\Core\Context\Context;
|
|
use TYPO3\CMS\Core\Http\ResponseFactory;
|
|
use TYPO3\CMS\Core\Routing\PageArguments;
|
|
use TYPO3\CMS\Core\Site\SiteFinder;
|
|
use TYPO3\CMS\Frontend\Authentication\FrontendUserAuthentication;
|
|
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
|
|
|
|
/**
|
|
* AbstractEIDController
|
|
*/
|
|
class AbstractEIDController
|
|
{
|
|
|
|
/**
|
|
* ValidationTrait
|
|
*/
|
|
use ValidationTrait {
|
|
validateAgainstSchema as traitValidateAgainstSchema;
|
|
}
|
|
|
|
/**
|
|
* FormatResultTrait
|
|
*/
|
|
use FormatResultTrait;
|
|
|
|
/**
|
|
* @var BackendConfigurationManager
|
|
*/
|
|
protected $configurationManager;
|
|
|
|
/**
|
|
* ApiUtility
|
|
*/
|
|
protected $apiUtility = null;
|
|
|
|
/*
|
|
* extension Key
|
|
*/
|
|
protected $extensionKey = null;
|
|
|
|
/*
|
|
* objectManager
|
|
*/
|
|
protected $objectManager = null;
|
|
|
|
/*
|
|
* storagePids
|
|
*/
|
|
protected $settings = null;
|
|
|
|
/*
|
|
* storagePids
|
|
*/
|
|
protected $storagePids = [];
|
|
|
|
/*
|
|
* logManager
|
|
*/
|
|
protected $logManager = null;
|
|
|
|
/*
|
|
* logger
|
|
*/
|
|
protected $importLogger = null;
|
|
|
|
/**
|
|
* uriMapping
|
|
*/
|
|
protected $uriMapping = null;
|
|
|
|
/**
|
|
* uriMappingValues
|
|
*/
|
|
protected $uriMappingValues = [];
|
|
|
|
|
|
/*
|
|
* returns the extensionkey set in the exended calss
|
|
*/
|
|
public function getExtensionKey() {
|
|
return $this->extensionKey;
|
|
}
|
|
|
|
/**
|
|
* Construct
|
|
*
|
|
* @param ObjectManager $objectManager
|
|
* @param array $configuration
|
|
*/
|
|
public function __construct(ObjectManager $objectManager = null,
|
|
array $configuration = [])
|
|
{
|
|
$this->objectManager = GeneralUtility::makeInstance(
|
|
ObjectManager::class
|
|
);
|
|
$this->initFrontendController();
|
|
$this->configurationManager = GeneralUtility::makeInstance(
|
|
ConfigurationManagerInterface::class
|
|
);
|
|
$this->apiUtility = GeneralUtility::makeInstance(
|
|
\Cjel\TemplatesAide\Utility\ApiUtility::class
|
|
);
|
|
$frameworkConfiguration = $this->configurationManager->getConfiguration(
|
|
ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK,
|
|
$this->getExtensionKey()
|
|
);
|
|
$this->configurationManager->setConfiguration(
|
|
$frameworkConfiguration
|
|
);
|
|
$this->settings = $frameworkConfiguration;
|
|
$this->storagePids = explode(
|
|
',',
|
|
str_replace(
|
|
' ',
|
|
'',
|
|
$frameworkConfiguration['persistence']['storagePid']
|
|
)
|
|
);
|
|
$this->logManager = GeneralUtility::makeInstance(
|
|
LogManager::Class
|
|
);
|
|
$this->importLogger = $this->logManager->getLogger(
|
|
'importLogger'
|
|
);
|
|
$this->reflectionService = GeneralUtility::makeInstance(
|
|
ReflectionService::class
|
|
);
|
|
$classInfo = $this->reflectionService->getClassSchema(
|
|
get_class($this)
|
|
);
|
|
foreach ($classInfo->getInjectMethods() as $method => $className) {
|
|
if (version_compare(TYPO3_branch, '10.0', '>=')) {
|
|
$className = $className
|
|
->getFirstParameter()
|
|
->getDependency();
|
|
}
|
|
$class = GeneralUtility::makeInstance(
|
|
$className
|
|
);
|
|
$this->{$method}($class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize frontentController
|
|
*/
|
|
private function initFrontendController()
|
|
{
|
|
$currentDomain = strtok(GeneralUtility::getIndpEnv('HTTP_HOST'), ':');
|
|
$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
|
|
->getQueryBuilderForTable('sys_domain');
|
|
$queryBuilder->setRestrictions(
|
|
GeneralUtility::makeInstance(DefaultRestrictionContainer::class)
|
|
);
|
|
$result = $queryBuilder
|
|
->select('uid', 'pid', 'domainName')
|
|
->from('sys_domain')
|
|
->where(
|
|
$queryBuilder->expr()->eq(
|
|
'domainName',
|
|
$queryBuilder->createNamedParameter(
|
|
$currentDomain,
|
|
\PDO::PARAM_STR
|
|
)
|
|
)
|
|
)
|
|
->orderBy('sorting', 'ASC')
|
|
->execute()
|
|
->fetchAll();
|
|
//if (count($result) < 1) {
|
|
// throw new \Exception('Domain not configured');
|
|
//}
|
|
|
|
|
|
$context = GeneralUtility::makeInstance(Context::class);
|
|
|
|
|
|
|
|
|
|
$siteFinder = GeneralUtility::makeInstance(SiteFinder::class);
|
|
$site = $siteFinder->getSiteByPageId(1049);
|
|
|
|
$siteLanguage = reset($site->getLanguages());
|
|
|
|
$pageArguments = GeneralUtility::makeInstance(
|
|
PageArguments::class,
|
|
1049,
|
|
'0',
|
|
[]
|
|
);
|
|
|
|
$frontendUser = GeneralUtility::makeInstance(
|
|
FrontendUserAuthentication::class
|
|
);
|
|
|
|
|
|
|
|
|
|
$frontendController = GeneralUtility::makeInstance(
|
|
TypoScriptFrontendController::class,
|
|
$context,
|
|
$site,
|
|
$siteLanguage,
|
|
$pageArguments,
|
|
$frontendUser
|
|
|
|
);
|
|
|
|
//die;
|
|
$GLOBALS['LANG'] = GeneralUtility::makeInstance(LanguageService::class);
|
|
$GLOBALS['LANG']->init('default');
|
|
$GLOBALS['TSFE'] = $frontendController;
|
|
//$frontendController->connectToDB();
|
|
//$frontendController->fe_user = EidUtility::initFeUser();
|
|
//$frontendController->id = 1049;
|
|
$frontendController->determineId();
|
|
//$frontendController->initTemplate();
|
|
$frontendController->getConfigArray();
|
|
//EidUtility::initTCA();
|
|
}
|
|
|
|
/**
|
|
* process incoming requst
|
|
*
|
|
* checks if there is a method avaiable for the request and executes it, if
|
|
* found
|
|
*
|
|
* @param ServerRequestInterface $request
|
|
* @param ResponseInterface $response
|
|
* @return void
|
|
*/
|
|
public function processRequest(
|
|
ServerRequestInterface $request,
|
|
ResponseInterface $response = null
|
|
) {
|
|
if (!$response) {
|
|
$responseFactory = GeneralUtility::makeInstance(
|
|
ResponseFactory::class
|
|
);
|
|
$response = $responseFactory->createResponse();
|
|
}
|
|
$apiObject = explode('/', $request->getUri()->getPath())[3];
|
|
$apiObjectId = explode('/', $request->getUri()->getPath())[4];
|
|
if (!$apiObject) {
|
|
return $response->withStatus(404);
|
|
}
|
|
$httpMethod = strtolower($request->getMethod());
|
|
if ($this->uriMapping) {
|
|
$uriParts = explode('/', $request->getUri()->getPath());
|
|
$uriParts = array_slice($uriParts, 3);
|
|
foreach ($this->uriMapping[$httpMethod] as $mapping => $function) {
|
|
$mappingParts = explode('/', $mapping);
|
|
$mappingParts = array_slice($mappingParts, 1);
|
|
$max = max(count($mappingParts), count($uriParts));
|
|
$mappingMatching = true;
|
|
for ($i = 0; $i < $max; $i++) {
|
|
if ($uriParts[$i] == $mappingParts[$i]) {
|
|
continue;
|
|
}
|
|
if (
|
|
$uriParts[$i]
|
|
&& substr($mappingParts[$i], 0, 1) == '{'
|
|
&& substr($mappingParts[$i], -1, 1) == '}'
|
|
) {
|
|
$mappingKey = substr($mappingParts[$i], 1, -1);
|
|
$this->uriMappingValues[$mappingKey] = $uriParts[$i];
|
|
continue;
|
|
}
|
|
$mappingMatching = false;
|
|
}
|
|
if ($mappingMatching == true) {
|
|
$requestMethod = $function . 'Request';
|
|
}
|
|
}
|
|
} else {
|
|
if ($apiObjectId) {
|
|
$requestMethod = $httpMethod
|
|
. ucfirst($apiObject)
|
|
. 'SingleRequest';
|
|
$request->apiObjectId = $apiObjectId;
|
|
} else {
|
|
$requestMethod = $httpMethod
|
|
. ucfirst($apiObject)
|
|
. 'Request';
|
|
}
|
|
}
|
|
if (method_exists($this, $requestMethod)) {
|
|
$responseData = $this->$requestMethod($request, $response);
|
|
$response = $response->withHeader(
|
|
'Content-Type',
|
|
'application/json; charset=utf-8'
|
|
);
|
|
if (is_array($responseData)
|
|
&& array_key_exists('errors', $responseData)
|
|
) {
|
|
$response = $response->withStatus(400);
|
|
}
|
|
if (is_array($responseData)
|
|
&& array_key_exists('status', $responseData)
|
|
) {
|
|
if (is_array($responseData['status'])) {
|
|
$response = $response->withStatus(
|
|
$responseData['status'][0],
|
|
$responseData['status'][1]
|
|
);
|
|
} else {
|
|
$response = $response->withStatus($responseData['status']);
|
|
}
|
|
}
|
|
$response->getBody()->write(\json_encode($responseData));
|
|
return $response;
|
|
} else {
|
|
return $response->withStatus(404);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function persistAll()
|
|
{
|
|
(GeneralUtility::makeInstance(
|
|
PersistenceManager::class
|
|
))->persistAll();
|
|
}
|
|
|
|
|
|
/**
|
|
* return function
|
|
*
|
|
* @param array $result
|
|
* @return void
|
|
*/
|
|
protected function returnFunction(
|
|
$result = []
|
|
) {
|
|
$result = $this->formatResult($result, 'asd');
|
|
unset($result['cid']);
|
|
unset($result['componentMode']);
|
|
unset($result['isValid']);
|
|
if ($result) {
|
|
if (!empty($this->errors)) {
|
|
return $result;
|
|
} else {
|
|
return [
|
|
'metadata' => [
|
|
'total' => count($result),
|
|
'count' => count($result),
|
|
],
|
|
'result' => $result,
|
|
];
|
|
}
|
|
} else {
|
|
return [];
|
|
}
|
|
//return $result;
|
|
}
|
|
|
|
}
|