vendor/alnv/catalog-manager/library/alnv/OptionsGetter.php line 105

Open in your IDE?
  1. <?php
  3. namespace CatalogManager;
  5. use Contao\StringUtil;
  7. class OptionsGetter extends CatalogController
  8. {
  10.     protected $strModuleID;
  11.     protected $arrCache = [];
  12.     protected $arrField = [];
  13.     protected $arrQueries = [];
  14.     protected $arrCatalog = [];
  15.     protected $strActiveTable = '';
  16.     protected $arrActiveEntity = [];
  17.     protected $arrCatalogFields = [];
  19.     public function __construct($arrField, $strModuleID = '', $arrQueries = [])
  20.     {
  22.         parent::__construct();
  24.         $this->arrField = $arrField;
  25.         $this->strModuleID = $strModuleID;
  27.         foreach ($arrQueries as $strQuery) if (!Toolkit::isEmpty($strQuery)) $this->arrQueries[] = $strQuery;
  29.         $this->import('CatalogInput');
  30.         $this->import('OrderByHelper');
  31.         $this->import('SQLQueryHelper');
  32.         $this->import('SQLQueryBuilder');
  33.         $this->import('CatalogDcExtractor');
  34.         $this->import('I18nCatalogTranslator');
  35.     }
  37.     public function isForeignKey()
  38.     {
  40.         if (isset($this->arrField['optionsType']) && $this->arrField['optionsType'] && $this->arrField['optionsType'] == 'useForeignKey') {
  42.             return true;
  43.         }
  45.         return false;
  46.     }
  48.     public function getForeignKey()
  49.     {
  51.         return $this->setForeignKey();
  52.     }
  54.     public function getOptions()
  55.     {
  57.         switch ($this->arrField['optionsType'] ?? '') {
  59.             case 'useOptions':
  60.                 return $this->getKeyValueOptions();
  62.             case 'useForeignKey':
  63.                 $this->arrField['dbTableKey'] = 'id';
  64.                 return $this->getDbOptions();
  66.             case 'useDbOptions':
  67.                 return $this->getDbOptions();
  69.             case 'useActiveDbOptions':
  70.                 return $this->getActiveDbOptions();
  71.         }
  73.         if (!isset($this->arrField['optionsType']) && in_array($this->arrField['fieldname'], ['country', 'countries']) && in_array($this->arrField['type'], ['radio', 'select', 'checkbox'])) {
  75.             return \System::getCountries();
  76.         }
  78.         return [];
  79.     }
  81.     public function getTableEntities()
  82.     {
  84.         switch ($this->arrField['optionsType'] ?? '') {
  86.             case 'useDbOptions':
  87.             case 'useForeignKey':
  89.                 if (!$this->arrField['dbTable'] || !$this->arrField['dbTableKey'] || !$this->arrField['dbTableValue']) {
  90.                     return null;
  91.                 }
  93.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->tableExists($this->arrField['dbTable'])) {
  94.                     return null;
  95.                 }
  97.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->fieldExists($this->arrField['dbTableKey'], $this->arrField['dbTable'])) {
  98.                     return null;
  99.                 }
  101.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->fieldExists($this->arrField['dbTableValue'], $this->arrField['dbTable'])) {
  102.                     return null;
  103.                 }
  105.                 return $this->getResults(true);
  107.             case 'useActiveDbOptions':
  109.                 $strDbColumn = $this->arrField['dbColumn'];
  111.                 if (!$this->arrField['dbTable'] || !$strDbColumn) {
  112.                     return null;
  113.                 }
  115.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->tableExists($this->arrField['dbTable'])) {
  116.                     return null;
  117.                 }
  119.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->fieldExists($strDbColumn, $this->arrField['dbTable'])) {
  120.                     return null;
  121.                 }
  123.                 return $this->getResults(false);
  124.         }
  126.         return null;
  127.     }
  129.     protected function setValueToOption(&$arrOptions, $strValue, $strLabel = '', $strTable = '')
  130.     {
  132.         $strKey = $strValue;
  133.         $strKey = \StringUtil::decodeEntities($strKey);
  134.         $strText = $strLabel ?: $strKey;
  136.         if (isset($this->arrField['dbParseDate']) && $this->arrField['dbParseDate']) {
  137.             $strFormat = $this->arrField['dbMonthBeginFormat'] ?: 'F Y';
  138.             if ($this->arrField['dbDateFormat'] == 'yearBegin') $strFormat = $this->arrField['dbYearBeginFormat'] ?: 'Y';
  139.             if ($this->arrField['dbDateFormat'] == 'dayBegin') $strFormat = $this->arrField['dbDayBeginFormat'] ?: 'l, F Y';
  140.             $strKey = DateInput::parseValue($strValue, ['rgxp' => $this->arrField['dbDateFormat']], []);
  141.             $strText = \Controller::parseDate($strFormat, $strValue);
  142.         } else {
  143.             $strText = $this->I18nCatalogTranslator->get('option', $strKey, ['title' => $strText, 'table' => $strTable]);
  144.         }
  146.         if ($strKey && !in_array($strKey, array_keys($arrOptions))) {
  147.             $arrOptions[$strKey] = $strText;
  148.         }
  150.         /*
  151.         if ($strValue && !in_array($strValue, $arrOptions)) {
  152.             $strValue = \StringUtil::decodeEntities($strValue);
  153.             $strTitle = $strValue;
  154.             if (isset($this->arrField['dbParseDate']) && $this->arrField['dbParseDate']) {
  155.                 $strFormat = $this->arrField['dbMonthBeginFormat'] ?: 'F Y';
  156.                 if ($this->arrField['dbDateFormat'] == 'yearBegin') $strFormat = $this->arrField['dbYearBeginFormat'] ?: 'Y';
  157.                 if ($this->arrField['dbDateFormat'] == 'dayBegin') $strFormat = $this->arrField['dbDayBeginFormat'] ?: 'l, F Y';
  158.                 $strValue = DateInput::parseValue($strValue, ['rgxp' => $this->arrField['dbDateFormat']], []);
  159.                 $strTitle = \Controller::parseDate($strFormat, $strValue);
  160.             } else {
  161.                 $strTitle = $this->I18nCatalogTranslator->get('option', $strTitle, ['title' => $strLabel, 'table' => $strTable]);
  162.             }
  163.             $arrOptions[$strValue] = \StringUtil::decodeEntities($strTitle);
  164.         }
  165.         */
  167.         return $arrOptions;
  168.     }
  170.     protected function parseCatalogValues($varValue, $strFieldname, $arrCatalog)
  171.     {
  173.         $arrField = $this->arrCatalogFields[$strFieldname];
  175.         switch ($arrField['type']) {
  176.             case 'select':
  177.                 return Select::parseValue($varValue, $arrField, $arrCatalog);
  178.             case 'checkbox':
  179.                 return Checkbox::parseValue($varValue, $arrField, $arrCatalog);
  180.             case 'radio':
  181.                 return Radio::parseValue($varValue, $arrField, $arrCatalog);
  182.             case 'text':
  183.                 return Text::parseValue($varValue, $arrField, $arrCatalog);
  184.         }
  186.         return $varValue;
  187.     }
  189.     protected function getResults($blnUseValidValue = false)
  190.     {
  192.         $arrSQLQuery = [
  193.             'table' => $this->arrField['dbTable']
  194.         ];
  196.         $this->getActiveTable();
  197.         $this->getActiveEntityValues();
  198.         $strOrderBy = $this->getOrderBy();
  199.         $arrDbTaxonomies = Toolkit::deserialize($this->arrField['dbTaxonomy']);
  200.         $arrQueries = is_array($arrDbTaxonomies) && isset($arrDbTaxonomies['query']) ? $arrDbTaxonomies['query'] : [];
  202.         $arrSQLQuery['where'] = Toolkit::parseQueries($arrQueries, function ($arrQuery) use ($blnUseValidValue) {
  204.             $blnValidValue = true;
  205.             $blnIgnoreEmptyValues = isset($this->arrField['dbIgnoreEmptyValues']) && $this->arrField['dbIgnoreEmptyValues'];
  207.             if ($blnIgnoreEmptyValues && in_array($arrQuery['operator'], ['isEmpty', 'isNotEmpty'])) $blnIgnoreEmptyValues = false;
  209.             $arrQuery['value'] = $this->getParseQueryValue($arrQuery['value'], $arrQuery['operator'], $blnValidValue);
  210.             $arrQuery['allowEmptyValues'] = $blnIgnoreEmptyValues ? false : true;
  212.             if (!$blnValidValue && $blnUseValidValue) return null;
  214.             return $arrQuery;
  215.         });
  217.         if (is_array($this->arrQueries) && !empty($this->arrQueries)) {
  218.             $arrSQLQuery['where'][] = [
  219.                 'multiple' => true,
  220.                 'operator' => 'regexp',
  221.                 'field' => $this->arrField['dbTableValue'],
  222.                 'value' => implode(',', $this->arrQueries)
  223.             ];
  224.         }
  226.         $strWhereStatement = $this->SQLQueryBuilder->getWhereQuery($arrSQLQuery);
  228.         if (Toolkit::isEmpty($strOrderBy)) {
  229.             $this->CatalogDcExtractor->initialize($this->arrField['dbTable']);
  230.             $this->CatalogDcExtractor->extract();
  231.             if ($this->CatalogDcExtractor->hasOrderByStatement()) {
  232.                 $strOrderBy = ' ORDER BY ' . $this->CatalogDcExtractor->getOrderByStatement();
  233.             }
  234.         }
  236.         $strQuery = sprintf('SELECT * FROM %s%s%s', $this->arrField['dbTable'], $strWhereStatement, $strOrderBy);
  238.         if (isset($GLOBALS['TL_HOOKS']['catalogManagerModifyOptionsGetter']) && is_array($GLOBALS['TL_HOOKS']['catalogManagerModifyOptionsGetter'])) {
  239.             foreach ($GLOBALS['TL_HOOKS']['catalogManagerModifyOptionsGetter'] as $callback) {
  240.                 $this->import($callback[0]);
  241.                 $this->{$callback[0]}->{$callback[1]}($strQuery, $arrSQLQuery, $this->arrField, $this->strModuleID);
  242.             }
  243.         }
  245.         $objDbOptions = $this->SQLQueryHelper->SQLQueryBuilder->Database->prepare($strQuery)->execute($this->SQLQueryBuilder->getValues());
  247.         return $objDbOptions;
  248.     }
  250.     protected function getActiveTable()
  251.     {
  253.         $this->strActiveTable = \Input::get('table') ? \Input::get('table') : \Input::get('ctlg_table');
  255.         if (Toolkit::isEmpty($this->strActiveTable) && \Input::get('do')) {
  257.             $arrTables = Toolkit::getBackendModuleTablesByDoAttribute(\Input::get('do'));
  259.             if (is_array($arrTables) && isset($arrTables[0])) $this->strActiveTable = $arrTables[0];
  260.         }
  261.     }
  263.     protected function getDbOptions()
  264.     {
  266.         $arrOptions = [];
  267.         $objDbOptions = $this->getTableEntities();
  269.         if ($objDbOptions === null) return $arrOptions;
  270.         if (!$objDbOptions->numRows) return $arrOptions;
  272.         while ($objDbOptions->next()) {
  273.             $this->setValueToOption($arrOptions, $objDbOptions->{$this->arrField['dbTableKey']}, $objDbOptions->{$this->arrField['dbTableValue']}, $this->arrField['dbTable']);
  274.         }
  276.         $arrOrderBy = \StringUtil::deserialize($this->arrField['dbOrderBy'], true);
  278.         if (empty($arrOrderBy) && count($arrOptions) < 50) {
  279.             asort($arrOptions);
  280.         }
  282.         if (isset($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions']) && is_array($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions'])) {
  283.             foreach ($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions'] as $arrCallback) {
  284.                 if (is_array($arrCallback)) {
  285.                     $this->import($arrCallback[0]);
  286.                     $this->{$arrCallback[0]}->{$arrCallback[1]}($arrOptions, $this->arrField, $this->arrCatalog, $this->arrCatalogFields);
  287.                 }
  288.             }
  289.         }
  291.         return $arrOptions;
  292.     }
  294.     protected function getActiveDbOptions()
  295.     {
  297.         $arrOptions = [];
  298.         $objEntities = $this->getTableEntities();
  299.         $strDbColumn = $this->arrField['dbColumn'];
  301.         if ($objEntities === null) return $arrOptions;
  302.         if (!$objEntities->numRows) return $arrOptions;
  304.         $this->arrCatalog = $this->SQLQueryHelper->getCatalogByTablename($this->arrField['dbTable']);
  305.         $this->arrCatalogFields = $this->SQLQueryHelper->getCatalogFieldsByCatalogTablename($this->arrField['dbTable']);
  307.         while ($objEntities->next()) {
  309.             $strOriginValue = $objEntities->{$strDbColumn};
  310.             $varValue = $this->parseCatalogValues($strOriginValue, $strDbColumn, []);
  312.             if (is_array($varValue)) {
  314.                 $arrLabels = array_values($varValue);
  315.                 $arrOriginValues = array_keys($varValue);
  317.                 if (!empty($arrLabels) && is_array($arrLabels)) {
  318.                     foreach ($arrLabels as $intPosition => $strLabel) {
  319.                         $this->setValueToOption($arrOptions, $arrOriginValues[$intPosition], $strLabel, $this->arrField['dbTable']);
  320.                     }
  321.                 }
  322.             } else {
  323.                 $this->setValueToOption($arrOptions, $strOriginValue, $varValue, $this->arrField['dbTable']);
  324.             }
  325.         }
  327.         $arrOrderBy = StringUtil::deserialize($this->arrField['dbOrderBy'], true);
  329.         if (empty($arrOrderBy) && count($arrOptions) < 50) {
  330.             asort($arrOptions);
  331.         }
  333.         if (isset($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions']) && is_array($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions'])) {
  334.             foreach ($GLOBALS['TL_HOOKS']['catalogManagerModifyOptions'] as $arrCallback) {
  335.                 if (is_array($arrCallback)) {
  336.                     $this->import($arrCallback[0]);
  337.                     $this->{$arrCallback[0]}->{$arrCallback[1]}($arrOptions, $this->arrField, $this->arrCatalog, $this->arrCatalogFields);
  338.                 }
  339.             }
  340.         }
  342.         return $arrOptions;
  343.     }
  345.     protected function getParseQueryValue($strValue = '', $strOperator = '', &$blnValidValue = true)
  346.     {
  348.         if (!empty($strValue) && is_string($strValue)) {
  350.             $strInsertTagValue = \Controller::replaceInsertTags($strValue);
  352.             if (!Toolkit::isEmpty($strInsertTagValue)) {
  354.                 $strValue = $strInsertTagValue;
  355.             }
  356.         }
  358.         if (!empty($strValue) && is_string($strValue) && strpos($strValue, '{{') !== false) {
  360.             $strActiveValue = '';
  361.             $arrTags = preg_split('/{{(([^{}]*|(?R))*)}}/', $strValue, -1, PREG_SPLIT_DELIM_CAPTURE);
  363.             $strInsertTag = implode('', $arrTags);
  364.             $strParameter = explode('::', $strInsertTag);
  365.             $strFieldname = $strParameter[0];
  367.             if ($strFieldname !== '' && $strFieldname !== null) {
  368.                 $strActiveValue = $this->arrActiveEntity[$strFieldname] ?? '';
  370.                 if (TL_MODE == 'FE') {
  371.                     $strActiveValue = $this->CatalogInput->getActiveValue($strFieldname);
  372.                 }
  374.                 if (TL_MODE == 'FE' && (Toolkit::isEmpty(\Input::post('FORM_SUBMIT')) && \Input::get('act' . $this->strModuleID))) {
  375.                     $strActiveValue = $this->arrActiveEntity[$strFieldname] ?: '';
  376.                 }
  378.                 if (isset($strParameter[1]) && $strParameter[1] == 'tree') {
  379.                     $objDatabase = \Database::getInstance();
  380.                     $objField = $objDatabase->prepare('SELECT * FROM tl_catalog_fields WHERE `fieldname` = ?')->limit(1)->execute($strFieldname); //@todo don`t work with multiple fieldnames
  382.                     if ($objField->numRows) {
  383.                         if ($objField->optionsType) {
  384.                             $objEntity = $objDatabase->prepare('SELECT * FROM ' . $objField->dbTable . ' WHERE `' . $objField->dbTableKey . '` = ?')
  385.                                 ->limit(1)
  386.                                 ->execute($strActiveValue);
  388.                             if ($objEntity->numRows) {
  389.                                 $strActiveValue = $objEntity->id ?: $strActiveValue;
  390.                             }
  391.                         }
  392.                     }
  393.                 }
  394.             }
  396.             $blnValidValue = $this->isValidValue($strActiveValue);
  397.             $strValue = $strActiveValue;
  398.         }
  400.         if (in_array($strOperator, ['contain', 'notContain']) && is_string($strValue)) {
  401.             $strValue = explode(',', $strValue);
  402.         }
  404.         return Toolkit::prepareValueForQuery($strValue);
  405.     }
  407.     protected function getKeyValueOptions()
  408.     {
  410.         $arrOptions = [];
  412.         if ($this->arrField['options']) {
  414.             $arrFieldOptions = \StringUtil::deserialize($this->arrField['options']);
  416.             if (!empty($arrFieldOptions) && is_array($arrFieldOptions)) {
  418.                 foreach ($arrFieldOptions as $arrOption) {
  420.                     $this->setValueToOption($arrOptions, $arrOption['key'], $arrOption['value']);
  421.                 }
  422.             }
  423.         }
  425.         return $arrOptions;
  426.     }
  428.     protected function setForeignKey()
  429.     {
  431.         $strLabelColumn = $this->arrField['dbTableValue'] ?: $this->arrField['dbTableKey'];
  433.         if (!$this->arrField['dbTable'] || !$strLabelColumn) {
  435.             return '';
  436.         }
  438.         return $this->arrField['dbTable'] . '.' . $strLabelColumn;
  439.     }
  441.     protected function getActiveEntityValues()
  442.     {
  444.         switch (TL_MODE) {
  446.             case 'BE':
  448.                 $strID = \Input::get('id');
  450.                 if (Toolkit::isEmpty($strID) || Toolkit::isEmpty($this->strActiveTable)) {
  452.                     return null;
  453.                 }
  455.                 if (!$this->SQLQueryHelper->SQLQueryBuilder->Database->tableExists($this->strActiveTable)) {
  457.                     return null;
  458.                 }
  460.                 $arrQuery = [
  462.                     'table' => $this->strActiveTable,
  464.                     'pagination' => [
  466.                         'limit' => 1
  467.                     ],
  469.                     'where' => [
  471.                         [
  472.                             'field' => 'id',
  473.                             'value' => $strID,
  474.                             'operator' => 'equal'
  475.                         ]
  476.                     ],
  478.                     'joins' => []
  479.                 ];
  481.                 $strLanguageColumn = '';
  482.                 $strDefaultLanguage = '';
  483.                 $objCatalog = $this->SQLQueryHelper->SQLQueryBuilder->Database->prepare('SELECT * FROM tl_catalog WHERE tablename = ? LIMIT 1')->execute($this->strActiveTable);
  485.                 if ($objCatalog->numRows) {
  487.                     if ($objCatalog->pTable && $this->SQLQueryHelper->SQLQueryBuilder->Database->fieldExists('pid', $this->strActiveTable)) {
  489.                         $arrQuery['joins'][] = [
  491.                             'field' => 'pid',
  492.                             'onField' => 'id',
  493.                             'multiple' => false,
  494.                             'table' => $this->strActiveTable,
  495.                             'onTable' => $objCatalog->pTable
  496.                         ];
  497.                     }
  499.                     if ($this->hasLanguageNavigationBar($objCatalog)) {
  501.                         $strDefaultLanguage = \Input::get('ctlg_language') ?: $objCatalog->fallbackLanguage;
  502.                         $strLanguageColumn = $objCatalog->languageEntityColumn;
  503.                     }
  504.                 }
  506.                 $this->arrActiveEntity = $this->SQLQueryBuilder->execute($arrQuery)->row();
  508.                 if ($strLanguageColumn && $strDefaultLanguage) {
  510.                     $this->arrActiveEntity[$strLanguageColumn] = $strDefaultLanguage;
  511.                 }
  513.                 return null;
  515.                 break;
  517.             case 'FE':
  519.                 if (!$this->arrField['pid']) {
  521.                     return null;
  522.                 }
  524.                 $objCatalog = $this->SQLQueryHelper->SQLQueryBuilder->Database->prepare('SELECT * FROM tl_catalog WHERE id = ?')->limit(1)->execute($this->arrField['pid']);
  526.                 if (!$objCatalog->tablename || !$this->SQLQueryHelper->SQLQueryBuilder->Database->tableExists($objCatalog->tablename)) {
  528.                     return null;
  529.                 }
  531.                 $strID = $this->strModuleID ? \Input::get('id' . $this->strModuleID) : \Input::get('id');
  532.                 $strAct = $this->strModuleID ? \Input::get('act' . $this->strModuleID) : \Input::get('act');
  534.                 if (!$strID && !$strAct) {
  536.                     return null;
  537.                 }
  539.                 $arrQuery = [
  541.                     'table' => $objCatalog->tablename,
  543.                     'pagination' => [
  545.                         'limit' => 1
  546.                     ],
  548.                     'where' => [
  550.                         [
  551.                             'field' => 'id',
  552.                             'value' => $strID,
  553.                             'operator' => 'equal'
  554.                         ]
  555.                     ],
  557.                     'joins' => []
  558.                 ];
  560.                 if ($objCatalog->pTable && $this->SQLQueryHelper->SQLQueryBuilder->Database->fieldExists('pid', $objCatalog->tablename)) {
  562.                     $arrQuery['joins'][] = [
  564.                         'field' => 'pid',
  565.                         'onField' => 'id',
  566.                         'multiple' => false,
  567.                         'onTable' => $objCatalog->pTable,
  568.                         'table' => $objCatalog->tablename
  569.                     ];
  570.                 }
  572.                 $this->arrActiveEntity = $this->SQLQueryBuilder->execute($arrQuery)->row();
  574.                 if ($this->hasLanguageNavigationBar($objCatalog)) {
  576.                     $this->arrActiveEntity[$objCatalog->languageEntityColumn] = $GLOBALS['TL_LANGUAGE'] ?: $objCatalog->fallbackLanguage;
  577.                 }
  579.                 break;
  581.         }
  583.         if (!is_array($this->arrActiveEntity)) {
  585.             $this->arrActiveEntity = [];
  586.         }
  587.     }
  589.     protected function getOrderBy()
  590.     {
  592.         if (isset($this->arrField['dbOrderBy'])) {
  593.             $arrOrderBy = \StringUtil::deserialize($this->arrField['dbOrderBy']);
  594.             if (is_array($arrOrderBy) && !empty($arrOrderBy)) {
  595.                 $this->arrField['_orderBy'] = $this->OrderByHelper->getOrderByQuery($arrOrderBy, $this->arrField['dbTable']);
  596.             }
  597.         }
  599.         if (isset($this->arrField['_orderBy']) && !Toolkit::isEmpty($this->arrField['_orderBy'])) {
  600.             return ' ' . $this->arrField['_orderBy'];
  601.         }
  603.         return '';
  604.     }
  606.     protected function isValidValue($strValue)
  607.     {
  609.         if (!Toolkit::isEmpty($strValue)) return true;
  611.         switch (TL_MODE) {
  612.             case 'BE':
  613.                 $strID = \Input::get('id');
  614.                 if (Toolkit::isEmpty($strID) || Toolkit::isEmpty($this->strActiveTable)) return false;
  615.                 break;
  616.             case 'FE':
  617.                 $strID = $this->strModuleID ? \Input::get('id' . $this->strModuleID) : \Input::get('id');
  618.                 if (\Input::get('act' . $this->strModuleID)) return true;
  619.                 if (!$strID) return false;
  620.                 break;
  621.         }
  623.         return true;
  624.     }
  626.     protected function hasLanguageNavigationBar($objCatalog)
  627.     {
  629.         return $objCatalog->enableLanguageBar && !in_array($objCatalog->mode, ['5', '6']) && $objCatalog->languageEntitySource == 'currentTable';
  630.     }
  631. }