/**
* Returns an instance of pager for a given configuration builder and a pager configuration
*
* @param Tx_PtExtlist_Domain_Configuration_Pager_PagerConfig $pagerConfiguration
* @return Tx_PtExtlist_Domain_Model_Pager_PagerInterface
*/
public function getInstance(Tx_PtExtlist_Domain_Configuration_Pager_PagerConfig $pagerConfiguration)
{
$pagerClassName = $pagerConfiguration->getPagerClassName();
$pager = $this->objectManager->get($pagerClassName, $pagerConfiguration);
Tx_PtExtbase_Assertions_Assert::isTrue(is_a($pager, 'Tx_PtExtlist_Domain_Model_Pager_PagerInterface'), array('message' => 'Given pager class does not implement pager interface! 1279541488'));
return $pager;
}
/**
* Constructor for criteria. Takes a collection of fields and a search string.
*
* @param Tx_PtExtlist_Domain_Configuration_Data_Fields_FieldConfigCollection $fields
* @param string $searchString
* @param array $searchParameter
*/
public function __construct(Tx_PtExtlist_Domain_Configuration_Data_Fields_FieldConfigCollection $fields, $searchString, array $searchParameter = array())
{
Tx_PtExtbase_Assertions_Assert::isPositiveInteger($fields->count(), array('message' => 'No field given to search in! 1313532571'));
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($searchString, array('message' => 'SearchString must not be empty! 1313532596'));
$this->fields = $fields;
$this->searchString = $searchString;
$this->searchParameter = $searchParameter;
}
/**
* Constructor for criteria. Takes a field name a value and a operator.
* Works like 'field' <operator> 'value'
*
* @param string $field
* @param string $value
* @param string $operator
*/
public function __construct($field = '', $value, $operator)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($field, array('message' => 'Field must not be empty! 1282849697'));
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($operator, array('message' => 'Operator must not be empty! 1282849699'));
$this->field = $field;
$this->value = $value;
$this->operator = $operator;
}
/**
* Initialize the Controller
*
* @param array $settings Settings container of the current extension
* @return void
*/
public function initializeAction()
{
parent::initializeAction();
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->settings['filterboxIdentifier'], array('message' => 'No filterbox identifier has been set. Set filterbox identifier in flexform! 1277889418'));
$this->filterboxIdentifier = $this->settings['filterboxIdentifier'];
$this->filterboxCollection = $this->dataBackend->getFilterboxCollection();
$this->filterbox = $this->filterboxCollection->getFilterboxByFilterboxIdentifier($this->filterboxIdentifier, true);
$this->pagerCollection = $this->dataBackend->getPagerCollection();
}
/**
* @return void
*/
public function initializeAction()
{
parent::initializeAction();
$this->exportListIdentifier = $this->settings['exportListIdentifier'];
if (!$this->exportListIdentifier) {
$this->exportListIdentifier = $this->listIdentifier;
}
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->exportListIdentifier, array('message' => 'No export list identifier set.', 1316446015));
}
/**
* Adds one item to the collection
*
* @param object object to add
* @param mixed array key / label (use namespaces here to avoid conflicts!)
* @param bool (optional) overwrite existing object, default is false
* @return void
* @throws Exception if the given label already exists and overwrite if false
*/
public function addItem($object, $label, $overwrite = false)
{
Tx_PtExtbase_Assertions_Assert::isNotEmpty($label, array('message' => 'Registry keys cannot be empty!'));
if (!$this->hasItem($label) || $overwrite == true) {
// add object to the collection
parent::addItem($object, $label);
} else {
throw new Exception('There is already an element stored with the label "' . $label . '" (and overwriting not permitted)!');
}
}
/**
* Build and return the renderer
*
* @param Tx_PtExtlist_Domain_Configuration_Renderer_RendererConfig $rendererConfiguration
* @return Tx_PtExtlist_Domain_Renderer_ConfigurableRendererInterface
*/
public function getRenderer(Tx_PtExtlist_Domain_Configuration_Renderer_RendererConfig $rendererConfiguration)
{
$rendererClassName = $rendererConfiguration->getRendererClassName();
Tx_PtExtbase_Assertions_Assert::classExists($rendererClassName, array('message' => 'Configured renderer class ' . $rendererClassName . ' does not exist! 1286986512'));
$renderer = $this->objectManager->get($rendererClassName);
/* @var $renderer Tx_PtExtlist_Domain_Renderer_ConfigurableRendererInterface */
Tx_PtExtbase_Assertions_Assert::isTrue(is_a($renderer, 'Tx_PtExtlist_Domain_Renderer_ConfigurableRendererInterface'), array('message' => 'Configured renderer class ' . $rendererClassName . ' does not implement Tx_PtExtlist_Domain_Renderer_RendererInterface 1286986513'));
$renderer->_injectConfiguration($rendererConfiguration);
$renderer->initRenderer();
return $renderer;
}
/**
* @param Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder
* @param $filterboxIdentifier
* @param array $filterBoxSettings
* @return Tx_PtExtlist_Domain_Configuration_Filters_FilterboxConfig
*/
public static function createInstance(Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder, $filterboxIdentifier, array $filterBoxSettings)
{
$filterboxConfiguration = new Tx_PtExtlist_Domain_Configuration_Filters_FilterboxConfig($configurationBuilder, $filterboxIdentifier, $filterBoxSettings);
$filterSettingsArray = is_array($filterBoxSettings['filterConfigs']) ? $filterBoxSettings['filterConfigs'] : array();
ksort($filterSettingsArray);
foreach ($filterSettingsArray as $arrayIndex => $filterSettings) {
Tx_PtExtbase_Assertions_Assert::isArray($filterSettings, array('message' => 'No array given for filter settings. Perhaps misconfiguration of TS for filterbox? 1280772788'));
$filterConfig = Tx_PtExtlist_Domain_Configuration_Filters_FilterConfigFactory::createInstance($configurationBuilder, $filterboxIdentifier, $filterSettings);
$filterboxConfiguration->addFilterConfig($filterConfig, $arrayIndex);
}
return $filterboxConfiguration;
}
/**
* Renders captions
*
* @param Tx_PtExtlist_Domain_Model_List_Header_ListHeader $listHeader
* @return Tx_PtExtlist_Domain_Model_List_Header_ListHeader $listHeader
*/
public function renderCaptions(Tx_PtExtlist_Domain_Model_List_Header_ListHeader $listHeader)
{
Tx_PtExtbase_Assertions_Assert::isNotNull($listHeader, array('message' => 'No header data available. 1280408235'));
$renderedListHeader = new Tx_PtExtlist_Domain_Model_List_Header_ListHeader($listHeader->getListIdentifier());
foreach ($listHeader as $headerColumn) {
/* @var $headerColumn Tx_PtExtlist_Domain_Model_List_Header_HeaderColumn */
if ($headerColumn->getColumnConfig()->isAccessable() && $headerColumn->getIsVisible()) {
$label = $this->renderColumnLabel($headerColumn);
$renderedListHeader->createAndAddCell($label, $headerColumn->getColumnIdentifier());
}
}
return $renderedListHeader;
}
/**
* Set and validate the config values
*
* @return void
*/
protected function initByTsConfig()
{
$this->dateIteratorStart = (int) Tx_PtExtlist_Utility_RenderValue::stdWrapIfPlainArray($this->filterConfig->getSettings('dateIteratorStart'));
Tx_PtExtbase_Assertions_Assert::isPositiveInteger($this->dateIteratorStart, false, array('message' => 'The Value dateIteratorStart is not given. 1314608757'));
$this->dateIteratorEnd = (int) Tx_PtExtlist_Utility_RenderValue::stdWrapIfPlainArray($this->filterConfig->getSettings('dateIteratorEnd'));
Tx_PtExtbase_Assertions_Assert::isPositiveInteger($this->dateIteratorEnd, false, array('message' => 'The Value dateIteratorEnd is not given. 1314608758'));
$this->dateIteratorFormat = $this->filterConfig->getSettings('dateIteratorFormat');
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->dateIteratorFormat, array('message' => 'The Value dateIteratorFormat is not given. 1314608759'));
$this->dateIteratorIncrement = strtolower(trim($this->filterConfig->getSettings('dateIteratorIncrement')));
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->dateIteratorIncrement, array('message' => 'The Value dateIteratorIncrement is not given. 1314608760'));
Tx_PtExtbase_Assertions_Assert::isTrue(in_array($this->dateIteratorIncrement, array('s', 'i', 'h', 'd', 'm', 'y')), array('message' => "The parameter dateIteratorIncrement has to be out of 's', 'i', 'h', 'd', 'm', 'y'"));
Tx_PtExtbase_Assertions_Assert::isTrue($this->dateIteratorStart < $this->dateIteratorEnd, array('message' => 'The Value dateIteratorStart (' . $this->dateIteratorStart . ') is higher than dateIteratorEnd (' . $this->dateIteratorEnd . ')'));
}
/**
* Determine the dataProvider to use for filter options
*
* TODO: Test me!
* @param Tx_PtExtlist_Domain_Configuration_Filters_FilterConfig $filterConfig
* @return string dataProviderClass
*/
protected function determineDataProviderClass(Tx_PtExtlist_Domain_Configuration_Filters_FilterConfig $filterConfig)
{
if ($filterConfig->getSettings('dataProviderClassName')) {
$dataProviderClassName = $filterConfig->getSettings('dataProviderClassName');
} else {
if ($filterConfig->getSettings('options')) {
$dataProviderClassName = 'Tx_PtExtlist_Domain_Model_Filter_DataProvider_ExplicitData';
} else {
$dataProviderClassName = 'Tx_PtExtlist_Domain_Model_Filter_DataProvider_GroupData';
}
}
Tx_PtExtbase_Assertions_Assert::isTrue(class_exists($dataProviderClassName), array('message' => 'The defined DataProviderClass "' . $dataProviderClassName . '" does not exist! 1283535558'));
return $dataProviderClassName;
}
/**
* Returns an instance of a data mapper for a given data mapper class name.
*
* @param Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder
* @return mixed
*/
public function createDataMapper(Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder)
{
$dataBackendConfiguration = $configurationBuilder->buildDataBackendConfiguration();
$dataMapperClassName = $dataBackendConfiguration->getDataMapperClass();
$dataMapper = $this->objectManager->get($dataMapperClassName, $configurationBuilder);
/** @var Tx_PtExtlist_Domain_DataBackend_Mapper_AbstractMapper $dataMapper */
$mapperConfiguration = $configurationBuilder->buildFieldsConfiguration();
// Check whether mapper implements interface
Tx_PtExtbase_Assertions_Assert::isTrue($dataMapper instanceof Tx_PtExtlist_Domain_DataBackend_Mapper_MapperInterface, array('message' => 'Data mapper must implement data mapper interface! 1280415471'));
$dataMapper->_injectConfigurationBuilder($configurationBuilder);
$dataMapper->_injectMapperConfiguration($mapperConfiguration);
$dataMapper->init();
return $dataMapper;
}
/**
* @param $query
* @return Tx_PtExtlist_Domain_DataBackend_DataSource_Typo3DataSource
* @throws Exception
*/
public function executeQuery($query)
{
try {
$this->startTimeMeasure();
$this->resource = $this->connection->sql_query($query);
Tx_PtExtbase_Assertions_Assert::isMySQLRessource($this->resource, $this->dbObj);
$this->stopTimeMeasure();
} catch (Exception $e) {
throw new Exception('Error while retrieving data from database using typo3 db object.<br>
Error: ' . $e->getMessage() . ' sql_error says: ' . $this->connection->sql_error() . ' 1280400023<br><br>
SQL QUERY: <br>
</strong><hr>' . nl2br($query) . '<hr><strong>', 1280400023);
}
return $this;
}
/**
* Factory method for filter boxes. Returns filterbox for a given filterbox configuration and list identifier
*
* @param Tx_PtExtlist_Domain_Configuration_Filters_FilterboxConfig $filterboxConfiguration
* @return Tx_PtExtlist_Domain_Model_Filter_Filterbox
*/
public function createInstance(Tx_PtExtlist_Domain_Configuration_Filters_FilterboxConfig $filterboxConfiguration)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($filterboxConfiguration->getListIdentifier(), array('message' => 'List identifier must not be empty 1277889458'));
$filterbox = $this->objectManager->get('Tx_PtExtlist_Domain_Model_Filter_Filterbox');
/* @var $filterbox Tx_PtExtlist_Domain_Model_Filter_Filterbox */
$filterbox->_injectFilterboxConfiguration($filterboxConfiguration);
$filterbox->_injectFilterboxFactory($this);
foreach ($filterboxConfiguration as $filterConfiguration) {
$filter = $this->filterFactory->createInstance($filterConfiguration);
$filter->_injectFilterbox($filterbox);
$filterbox->addFilter($filter, $filter->getFilterIdentifier());
}
$sessionPersistenceManager = $this->sessionPersistenceManagerBuilder->getInstance();
$sessionPersistenceManager->registerObjectAndLoadFromSession($filterbox);
return $filterbox;
}
/**
* Initialize additional class properties
*/
public function initConfiguration()
{
parent::initConfiguration();
//echo 's';
$this->templatePath = $this->exportConfiguration->getSettings('templatePath');
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->templatePath, array('message' => 'No template path given for fluid export! 1284621481'));
$this->setTemplatePathAndFilename(\TYPO3\CMS\Core\Utility\GeneralUtility::getFileAbsFileName($this->templatePath));
$this->paperSize = strtolower($this->exportConfiguration->getSettings('paperSize'));
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($this->paperSize, array('message' => 'No PaperSize given for the PDF output! 1322585559'));
$this->paperOrientation = $this->exportConfiguration->getSettings('paperOrientation');
Tx_PtExtbase_Assertions_Assert::isInArray($this->paperOrientation, array('portrait', 'landscape'), array('message' => 'The Orientation must either be portrait or landscape! 1322585560'));
$this->cssFilePath = \TYPO3\CMS\Core\Utility\GeneralUtility::getFileAbsFileName($this->exportConfiguration->getSettings('cssFilePath'));
Tx_PtExtbase_Assertions_Assert::isTrue(file_exists($this->cssFilePath), array('message' => 'The CSS File with the filename ' . $this->cssFilePath . ' can not be found. 1322587627'));
$this->dompdfSourcePath = \TYPO3\CMS\Core\Utility\GeneralUtility::getFileAbsFileName($this->exportConfiguration->getSettings('dompdfSourcePath'));
Tx_PtExtbase_Assertions_Assert::isTrue(is_dir($this->dompdfSourcePath), array('message' => 'DomPdf source in path ' . $this->dompdfSourcePath . ' was not found. 1322753515'));
$this->dompdfSourcePath = substr($this->dompdfSourcePath, -1, 1) == '/' ? $this->dompdfSourcePath : $this->dompdfSourcePath . '/';
}
/**
* Returns list data structure for given domain objects.
* Uses configuration currently set in mapper.
*
* @param mixed $domainObjects
* @return Tx_PtExtlist_Domain_Model_List_ListData List data generated for given mapping configuration
*/
public function getMappedListData($domainObjects)
{
Tx_PtExtbase_Assertions_Assert::isNotNull($this->fieldConfigurationCollection, array('message' => 'No mapper configuration has been set for domain object mapper! 1281635601'));
$listData = new Tx_PtExtlist_Domain_Model_List_ListData();
foreach ($domainObjects as $domainObject) {
$listDataRow = new Tx_PtExtlist_Domain_Model_List_Row();
foreach ($this->fieldConfigurationCollection as $fieldConfiguration) {
/* @var $fieldConfiguration Tx_PtExtlist_Domain_Configuration_Data_Fields_FieldConfig */
$property = $this->getPropertyNameByFieldConfig($fieldConfiguration);
if ($property == '__object__') {
$value = $domainObject;
} else {
$value = $this->getObjectPropertyValueByProperty($domainObject, $property);
}
$listDataRow->createAndAddCell($value, $fieldConfiguration->getIdentifier());
}
$listData->addRow($listDataRow);
}
return $listData;
}
/**
*
* @param string $identifier aggregate identifier
* @param array $aggregateSettings
* @param Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder
* @throws Exception
*/
public function __construct($identifier, $aggregateSettings, Tx_PtExtlist_Domain_Configuration_ConfigurationBuilder $configurationBuilder)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($identifier, array('message' => 'No aggregate identifier specified. 1282891490'));
$this->identifier = $identifier;
if (!trim($aggregateSettings['fieldIdentifier'])) {
throw new Exception('No fieldIdentifier for aggregate given! 1282891630');
}
$this->fieldIdentifier = $configurationBuilder->buildFieldsConfiguration()->getFieldConfigByIdentifier($aggregateSettings['fieldIdentifier']);
if (!array_key_exists('method', $aggregateSettings) && !array_key_exists('special', $aggregateSettings)) {
throw new Exception('No aggregate method or special sql given for aggregate ' . $this->identifier . '! 1282891831');
}
if (array_key_exists('method', $aggregateSettings)) {
$this->method = trim($aggregateSettings['method']);
}
if (array_key_exists('scope', $aggregateSettings)) {
$this->scope = $aggregateSettings['scope'];
}
if (array_key_exists('special', $aggregateSettings)) {
$this->special = $aggregateSettings['special'];
$this->scope = 'query';
}
}
/**
* Translates a query an manipulates given query object
*
* TODO check, if there is already a constraint added to extbase query and use AND constraint then
* TODO use AND to connect more than one constraint
*
* @param Tx_PtExtlist_Domain_QueryObject_Criteria $criteria Criteria to be translated
* @param \TYPO3\CMS\Extbase\Persistence\Generic\Query $extbaseQuery Query to add criteria to
* @param \TYPO3\CMS\Extbase\Persistence\Repository $extbaseRepository Associated repository
*
* @return \TYPO3\CMS\Extbase\Persistence\Generic\Query
*
* @throws \Exception
*/
public static function translateCriteria(Tx_PtExtlist_Domain_QueryObject_Criteria $criteria, \TYPO3\CMS\Extbase\Persistence\Generic\Query $extbaseQuery, \TYPO3\CMS\Extbase\Persistence\Repository $extbaseRepository)
{
Tx_PtExtbase_Assertions_Assert::isTrue(is_a($criteria, 'Tx_PtExtlist_Domain_QueryObject_SimpleCriteria'), array('message' => 'Criteria is not a simple criteria! 1281724991'));
/* @var $criteria Tx_PtExtlist_Domain_QueryObject_SimpleCriteria */
$propertyName = self::getPropertyNameByCriteria($criteria);
switch ($criteria->getOperator()) {
case '.':
self::addConstraint($extbaseQuery, $extbaseQuery->contains($propertyName, $criteria->getValue()));
break;
case '=':
self::addConstraint($extbaseQuery, $extbaseQuery->equals($propertyName, $criteria->getValue()));
break;
case '<':
self::addConstraint($extbaseQuery, $extbaseQuery->lessThan($propertyName, $criteria->getValue()));
break;
case '>':
self::addConstraint($extbaseQuery, $extbaseQuery->greaterThan($propertyName, $criteria->getValue()));
break;
case '<=':
self::addConstraint($extbaseQuery, $extbaseQuery->lessThanOrEqual($propertyName, $criteria->getValue()));
break;
case '>=':
self::addConstraint($extbaseQuery, $extbaseQuery->greaterThanOrEqual($propertyName, $criteria->getValue()));
break;
case 'LIKE':
self::addConstraint($extbaseQuery, $extbaseQuery->like($propertyName, $criteria->getValue()));
break;
case 'IN':
self::addConstraint($extbaseQuery, $extbaseQuery->in($propertyName, $criteria->getValue()));
break;
default:
throw new Exception('No translation implemented for ' . $criteria->getOperator() . ' operator! 1281727494');
break;
}
return $extbaseQuery;
}
/**
* Renders list data
*
* @param Tx_PtExtlist_Domain_Model_List_ListData $listData
* @return Tx_PtExtlist_Domain_Model_List_ListData
*/
public function renderList(Tx_PtExtlist_Domain_Model_List_ListData $listData)
{
Tx_PtExtbase_Assertions_Assert::isNotNull($listData, array(message => 'No list data found in list. 1280405145'));
// We could get another type of list data here, so we have to instantiate this class
$listDataClassName = get_class($listData);
$renderedList = new $listDataClassName();
// We need some generic way to copy non-standard data from "old" list data to "new" list data
if (method_exists($renderedList, 'copyListData')) {
// TODO refactor this by using a getEmptyInstance method on the list data we want to copy.
$renderedList->copyListData($listData);
}
foreach ($listData as $rowIndex => $row) {
$renderedList->addRow($this->rowRenderer->renderRow($row, $rowIndex));
}
unset($listData);
return $renderedList;
}
private function initializeDbObj()
{
if (self::$dbObj === null) {
self::$dbObj = $GLOBALS['TYPO3_DB'];
}
}
/**
* Creates filter object for given filter class name
*
* @param string $filterClassName
* @return Tx_PtExtlist_Domain_Model_Filter_FilterInterface
*/
private function createFilterObject($filterClassName)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($filterClassName, array('message' => 'No filter class name given, check TS configuration! 1277889459'));
Tx_PtExtbase_Assertions_Assert::isTrue(class_exists($filterClassName), array('message' => 'Given filter class ' . $filterClassName . ' does not exist or is not loaded! 1277889460'));
$filter = $this->objectManager->get($filterClassName);
/* @var $filter Tx_PtExtlist_Domain_Model_Filter_FilterInterface */
Tx_PtExtbase_Assertions_Assert::isTrue(is_a($filter, 'Tx_PtExtlist_Domain_Model_Filter_FilterInterface'), array('message' => 'Given filter class does not implement filter interface! 1277889461'));
$filter->_injectGpVarsAdapter($this->getPostVarsAdapterFactory->getInstance());
return $filter;
}
protected function init()
{
$this->setRequiredValue('fileName', 'No fileName given for export file! 1284563488');
$this->setRequiredValue('fileExtension', 'No file extension given for export file! 1284620580');
$this->setRequiredValue('viewClassName', 'No viewClassName given for export file ' . $this->fileName . '1284563489');
Tx_PtExtbase_Assertions_Assert::isTrue(class_exists($this->viewClassName), array('message' => 'The class name "' . $this->viewClassName . '" for export view does not exist! 1284563683'));
$this->setBooleanIfExistsAndNotNothing('addDateToFilename');
$this->setValueIfExistsAndNotNothing('dateFormat');
$this->setValueIfExistsAndNotNothing('contentType');
if (array_key_exists('downloadtype', $this->settings)) {
$this->downloadType = $this->settings['downloadtype'] == 'D' ? self::FORCE_DOWNLOAD : self::OPEN_IN_BROWSER;
}
}
/**
* Returns configuration object for filterbox identifier
*
* @param string $filterboxIdentifier
* @return Tx_PtExtlist_Domain_Configuration_Filters_FilterboxConfig
*/
public function getFilterboxConfigurationByFilterboxIdentifier($filterboxIdentifier)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($filterboxIdentifier, array('message' => 'Filterbox identifier must not be empty! 1277889453'));
return $this->buildFilterConfiguration()->getItemById($filterboxIdentifier);
}
/**
* Init the dataProvider by TS-conifg
*
* @param array $filterSettings
*/
protected function initDataProviderByTsConfig($filterSettings)
{
$this->tsOptions = $this->filterConfig->getSettings('options');
Tx_PtExtbase_Assertions_Assert::isArray($this->tsOptions, array('message' => 'Options configured by TS has to be an array, ' . gettype($this->tsOptions) . ' given! 1284142006'));
}
/**
* Get the valueArray with the right objectNamespace
*
* @param Tx_PtExtbase_State_IdentifiableInterface $object
* @param string $key
* @param string $value
* @return array
*/
public function buildObjectValueArray(Tx_PtExtbase_State_IdentifiableInterface $object, $key, $value)
{
$nameSpace = $object->getObjectNamespace();
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($nameSpace, array('message' => 'No ObjectNamespace returned from Obejct ' . get_class($object) . '! 1280771624'));
return $this->buildNamespaceValueArray($nameSpace, $key, $value);
}
/**
* Build the SQL Query for an aggregate
*
* @param Tx_PtExtlist_Domain_Configuration_Data_Aggregates_AggregateConfig $aggregateConfig
* @return string
*/
protected function buildAggregateFieldSQLByConfig(Tx_PtExtlist_Domain_Configuration_Data_Aggregates_AggregateConfig $aggregateConfig)
{
$supportedMethods = array('sum', 'avg', 'min', 'max', 'count');
if ($aggregateConfig->getSpecial()) {
$aggregateFieldSQL = $aggregateConfig->getSpecial();
} else {
Tx_PtExtbase_Assertions_Assert::isInArray($aggregateConfig->getMethod(), $supportedMethods, array('info' => 'The given aggregate method "' . $aggregateConfig->getMethod() . '" is not supported by this DataBackend'));
$aggregateFieldSQL = strtoupper($aggregateConfig->getMethod()) . '(' . $aggregateConfig->getFieldIdentifier() . ')';
}
$aggregateFieldSQL .= ' AS ' . $aggregateConfig->getIdentifier();
return $aggregateFieldSQL;
}
/**
* Deletes a session value from TYPO3 FE _browser_ session or a BE user session
* *immediately* (does not wait for complete script execution)
*
* @param string $key name of session key to delete (array key)
* @throws Exception if no valid frontend user and no valid backend user found
*/
public function delete($key)
{
// TYPO3 Frontend mode
if (TYPO3_MODE == 'FE' && $GLOBALS['TSFE']->fe_user instanceof \TYPO3\CMS\Frontend\Authentication\FrontendUserAuthentication) {
if (!empty($GLOBALS['TSFE']->fe_user->sesData[$key])) {
unset($GLOBALS['TSFE']->fe_user->sesData[$key]);
$GLOBALS['TSFE']->fe_user->sesData_change = 1;
$GLOBALS['TSFE']->fe_user->storeSessionData();
if (TYPO3_DLOG) {
GeneralUtility::devLog(sprintf('Deleting "%s" from FE browser session in "$GLOBALS[\'TSFE\']->fe_user"', $key), 'pt_extbase');
}
}
// TYPO3 Backend mode
} else {
Tx_PtExtbase_Assertions_Assert::isInstanceOf($GLOBALS['BE_USER'], 't3lib_userAuth', array('message' => 'No valid backend user found!'));
$sesDat = unserialize($GLOBALS['BE_USER']->user['ses_data']);
if (!empty($sesDat[$key])) {
unset($sesDat[$key]);
$GLOBALS['BE_USER']->user['ses_data'] = !empty($sesDat) ? serialize($sesDat) : '';
// this is adapted from t3lib_userAuth::setAndSaveSessionData()
$GLOBALS['TYPO3_DB']->exec_UPDATEquery($GLOBALS['BE_USER']->session_table, 'ses_id=' . $GLOBALS['TYPO3_DB']->fullQuoteStr($GLOBALS['BE_USER']->user['ses_id'], $GLOBALS['BE_USER']->session_table), array('ses_data' => $GLOBALS['BE_USER']->user['ses_data']));
if (TYPO3_DLOG) {
GeneralUtility::devLog(sprintf('Deleting "%s" from BE user in "$GLOBALS[\'BE_USER\']"', $key), 'pt_extbase');
}
}
}
}
/**
* Deletes a session value from the TYPO3 FRONTEND user session *immediately* (does not wait for complete script execution)
*
* @param string name of session key to delete (array key)
* @return void
* @global object $GLOBALS['TSFE']->fe_user: tslib_feUserAuth Object
* @author Rainer Kuhn <*****@*****.**>
* @since 2005-09-23
*/
public function delete($key)
{
Tx_PtExtbase_Assertions_Assert::isInstanceOf($GLOBALS['TSFE']->fe_user, 'tslib_feUserAuth', array('message' => 'No valid frontend user found!'));
unset($GLOBALS['TSFE']->fe_user->uc[$key]);
$GLOBALS['TSFE']->fe_user->userData_change = 1;
$GLOBALS['TSFE']->fe_user->storeSessionData();
if (TYPO3_DLOG) {
\TYPO3\CMS\Core\Utility\GeneralUtility::devLog(sprintf('Deleting "%s" from FE user session in "$GLOBALS[\'TSFE\']->fe_user"', $key), 'pt_extbase');
}
}
private function restoreDbObjInAssertClass()
{
Tx_PtExtbase_Assertions_Assert::$dbObj = $this->dbObjTmp;
}
/**
* Check existance of given class and set the property
* @param string $queryInterpreterClassName
*/
protected function checkAndSetQueryInterpreterClass($queryInterpreterClassName)
{
Tx_PtExtbase_Assertions_Assert::isNotEmptyString($queryInterpreterClassName, array('message' => 'queryInterpreterClass must not be empty! 1281178538'));
Tx_PtExtbase_Assertions_Assert::isTrue(class_exists($queryInterpreterClassName), array('message' => ' QueryInterpreter class ' . $queryInterpreterClassName . ' does not exist! 1281178539'));
$this->queryInterpreterClass = $queryInterpreterClassName;
}
