vendor/alnv/catalog-manager/library/alnv/Toolkit.php line 394

Open in your IDE?
  1. <?php
  3. namespace CatalogManager;
  5. class Toolkit
  6. {
  9.     public static $arrDateRgxp = ['date', 'time', 'datim'];
  10.     public static $arrRequireSortingModes = ['4', '5', '6'];
  11.     public static $arrOperators = ['cut', 'copy', 'invisible'];
  12.     public static $arrDoNotRenderInFastMode = ['upload', 'map'];
  13.     public static $arrDigitRgxp = ['digit', 'natural', 'prcnt'];
  14.     public static $nullableOperators = ['isNotEmpty', 'isEmpty'];
  15.     public static $arrModeTypes = ['0', '1', '2', '3', '4', '5', '6'];
  16.     public static $arrArrayOptions = ['origin', 'catalogFields', 'catalogEntityFields'];
  17.     public static $arrSocialSharingButtons = ['mail', 'twitter', 'facebook', 'xing', 'linkedin'];
  18.     public static $arrImageExtensions = ['jpg', 'jpeg', 'gif', 'png', 'svg', 'svgz', 'bmp', 'tiff', 'tif'];
  19.     public static $arrFileExtensions = ['odt', 'ods', 'odp', 'odg', 'ott', 'ots', 'otp', 'otg', 'pdf', 'doc', 'docx', 'dot', 'dotx', 'xls', 'xlsx', 'xlt', 'xltx', 'ppt', 'pptx', 'pot', 'potx', 'mp3', 'mp4', 'm4a', 'm4v', 'webm', 'ogg', 'ogv', 'wma', 'wmv', 'ram', 'rm', 'mov', 'zip', 'rar', '7z'];
  20.     public static $arrSqlTypes = [
  22.         'c256' => "varchar(256) NOT NULL default ''",
  23.         'c1' => "char(1) NOT NULL default ''",
  24.         'c16' => "varchar(16) NOT NULL default ''",
  25.         'c32' => "varchar(32) NOT NULL default ''",
  26.         'c64' => "varchar(64) NOT NULL default ''",
  27.         'c128' => "varchar(128) NOT NULL default ''",
  28.         'c512' => "varchar(512) NOT NULL default ''",
  29.         'c1024' => "varchar(1024) NOT NULL default ''",
  30.         'c2048' => "varchar(2048) NOT NULL default ''",
  31.         'i5' => "smallint(5) unsigned NOT NULL default '0'",
  32.         'i10' => "int(10) unsigned NOT NULL default '0'",
  33.         'is10' => "int(10) signed NOT NULL default '0'",
  34.         'iNotNull10' => "int(10) unsigned NULL",
  35.         'isNotNull10' => "int(10) signed NULL",
  36.         'text' => "text NULL",
  37.         'longtext' => "longtext NULL",
  38.         'blob' => "blob NULL",
  39.         'longblob' => "longblob NULL",
  40.         'binary' => "binary(16) NULL"
  41.     ];
  43.     public static $arrFormTemplates = [
  45.         'checkbox' => 'form_checkbox',
  46.         'textarea' => 'form_textarea',
  47.         'number' => 'form_textfield',
  48.         'text' => 'form_textfield',
  49.         'date' => 'form_textfield',
  50.         'select' => 'form_select',
  51.         'upload' => 'form_upload',
  52.         'hidden' => 'form_hidden',
  53.         'radio' => 'form_radio'
  54.     ];
  56.     public static function invisiblePaletteFields()
  57.     {
  59.         return [
  61.             'invisible',
  62.             'start',
  63.             'stop'
  64.         ];
  65.     }
  68.     public static function columnOnlyFields()
  69.     {
  71.         return [
  73.             'dbColumn'
  74.         ];
  75.     }
  78.     public static function readOnlyFields()
  79.     {
  81.         return [
  83.             'message'
  84.         ];
  85.     }
  88.     public static function wrapperFields()
  89.     {
  91.         return [
  93.             'fieldsetStart',
  94.             'fieldsetStop'
  95.         ];
  96.     }
  99.     public static function excludeFromDc()
  100.     {
  102.         return [
  104.             'map',
  105.             'fieldsetStop',
  106.             'fieldsetStart'
  107.         ];
  108.     }
  111.     public static function setDcConformInputType($strType)
  112.     {
  114.         return $GLOBALS['TL_CATALOG_MANAGER']['FIELD_TYPE_CONVERTER'][$strType] ?? '';
  115.     }
  118.     public static function convertCatalogTypeToFormType($strType)
  119.     {
  121.         $arrFormTypes = [
  123.             'radio' => 'radio',
  124.             'map' => 'textfield',
  125.             'select' => 'select',
  126.             'upload' => 'upload',
  127.             'text' => 'textfield',
  128.             'date' => 'textfield',
  129.             'number' => 'textfield',
  130.             'hidden' => 'textfield',
  131.             'textarea' => 'textarea',
  132.             'checkbox' => 'checkbox',
  133.             'message' => 'catalogMessageWidget'
  134.         ];
  136.         return $arrFormTypes[$strType] ?: '';
  137.     }
  140.     public static function setCatalogConformInputType($strField)
  141.     {
  143.         $strType = $strField['inputType'] ?? '';
  145.         if (Toolkit::isEmpty($strType)) return '';
  147.         if (!Toolkit::isEmpty($strField['eval']['rgxp'] ?? '')) {
  148.             if (in_array($strField['eval']['rgxp'], self::$arrDateRgxp)) return 'date';
  149.         }
  151.         $arrInputTypes = [
  153.             'text' => 'text',
  154.             'radio' => 'radio',
  155.             'select' => 'select',
  156.             'password' => 'text',
  157.             'fileTree' => 'upload',
  158.             'textarea' => 'textarea',
  159.             'checkbox' => 'checkbox',
  160.         ];
  162.         return $arrInputTypes[$strType] ?? 'text';
  163.     }
  165.     public static function getSqlDataType($strType)
  166.     {
  168.         $strSql = self::$arrSqlTypes[$strType] ?? '';
  170.         return $strSql ?: "varchar(256) NOT NULL default ''";
  171.     }
  173.     public static function isDcConformField($arrField)
  174.     {
  176.         if (empty($arrField) && !is_array($arrField)) {
  177.             return false;
  178.         }
  180.         if (!isset($arrField['type'])) {
  181.             return false;
  182.         }
  184.         if (in_array($arrField['type'], self::excludeFromDc())) {
  185.             return false;
  186.         }
  188.         return true;
  189.     }
  192.     public static function columnsBlacklist()
  193.     {
  195.         return [
  197.             'id',
  198.             'pid',
  199.             'tstamp',
  200.             'origin',
  201.             'sorting',
  202.             'invisible',
  203.         ];
  204.     }
  207.     public static function customizeAbleFields()
  208.     {
  210.         return [
  212.             'title',
  213.             'alias',
  214.             'start',
  215.             'stop'
  216.         ];
  217.     }
  219.     public static function isNumericArray($arrValues): bool
  220.     {
  221.         foreach ($arrValues as $varValue) {
  222.             if (!is_numeric($varValue)) {
  223.                 return false;
  224.             }
  225.         }
  226.         return true;
  227.     }
  229.     public static function parseCatalog($arrCatalog)
  230.     {
  232.         $arrCatalog['cTables'] = self::parseStringToArray(($arrCatalog['cTables']?? ''));
  233.         $arrCatalog['languages'] = self::parseStringToArray(($arrCatalog['languages'] ?? ''));
  234.         $arrCatalog['operations'] = self::parseStringToArray(($arrCatalog['operations'] ??''));
  235.         $arrCatalog['panelLayout'] = self::parseStringToArray(($arrCatalog['panelLayout'] ??''));
  236.         $arrCatalog['labelFields'] = self::parseStringToArray(($arrCatalog['labelFields'] ??''));
  237.         $arrCatalog['headerFields'] = self::parseStringToArray(($arrCatalog['headerFields'] ??''));
  238.         $arrCatalog['sortingFields'] = self::parseStringToArray(($arrCatalog['sortingFields'] ??''));
  240.         return $arrCatalog;
  241.     }
  244.     public static function parseStringToArray($strValue)
  245.     {
  247.         if (isset($strValue) && $strValue && is_string($strValue)) {
  249.             return \StringUtil::deserialize($strValue, true);
  250.         }
  252.         if (is_array($strValue)) {
  254.             return $strValue;
  255.         }
  257.         return [];
  258.     }
  261.     public static function removeBreakLines($strValue)
  262.     {
  264.         if (!$strValue || !is_string($strValue)) {
  266.             return $strValue;
  267.         }
  269.         return preg_replace("/\r|\n/", "", $strValue);
  270.     }
  273.     public static function removeApostrophe($strValue)
  274.     {
  276.         if (!$strValue || !is_string($strValue)) {
  278.             return $strValue;
  279.         }
  281.         return str_replace("'", "", $strValue);
  282.     }
  285.     public static function parseConformSQLValue($varValue)
  286.     {
  288.         return str_replace('-', '_', $varValue);
  289.     }
  292.     public static function isAssoc($arrAssoc)
  293.     {
  295.         if (!is_array($arrAssoc)) return false;
  297.         $arrKeys = array_keys($arrAssoc);
  299.         return array_keys($arrKeys) !== $arrKeys;
  300.     }
  303.     public static function prepareValues4Db($arrValues)
  304.     {
  306.         $arrReturn = [];
  308.         if (!empty($arrValues) && is_array($arrValues)) {
  310.             foreach ($arrValues as $strKey => $varValue) {
  312.                 $arrReturn[$strKey] = self::prepareValue4Db($varValue);
  313.             }
  314.         }
  316.         return $arrReturn;
  317.     }
  320.     public static function prepareValue4Db($varValue)
  321.     {
  323.         if (!self::isDefined($varValue)) return $varValue;
  325.         if (is_array($varValue)) return implode(',', $varValue);
  327.         if (is_float($varValue)) return floatval($varValue);
  329.         return $varValue;
  330.     }
  333.     public static function prepareValueForQuery($varValue)
  334.     {
  336.         if (is_array($varValue)) {
  338.             if (!empty($varValue)) {
  340.                 $arrReturn = [];
  342.                 $varValue = array_filter($varValue, function ($varValue) {
  344.                     if ($varValue === '0') return true;
  346.                     return $varValue;
  347.                 });
  349.                 foreach ($varValue as $strKey => $strValue) {
  351.                     $arrReturn[$strKey] = Toolkit::prepareValueForQuery($strValue);
  352.                 }
  354.                 return $arrReturn;
  355.             } else {
  357.                 return '';
  358.             }
  359.         }
  361.         if (is_string($varValue) && $varValue === '0') return 0;
  362.         if (is_null($varValue)) return '';
  364.         return $varValue;
  365.     }
  368.     public static function deserialize($strValue)
  369.     {
  371.         $strValue = deserialize($strValue);
  373.         if (!is_array($strValue)) {
  375.             return is_string($strValue) ? [$strValue] : [];
  376.         }
  378.         return $strValue;
  379.     }
  382.     public static function getBooleanByValue($varValue)
  383.     {
  385.         if (!$varValue) {
  387.             return false;
  388.         }
  390.         return true;
  391.     }
  394.     public static function deserializeAndImplode($strValue, $strDelimiter = ',')
  395.     {
  397.         if (!$strValue || !is_string($strValue)) {
  399.             return '';
  400.         }
  402.         $arrValue = deserialize($strValue);
  404.         if (!empty($arrValue) && is_array($arrValue)) {
  406.             return implode($strDelimiter, $arrValue);
  407.         }
  409.         return '';
  410.     }
  413.     public static function isDefined($varValue)
  414.     {
  416.         if (is_numeric($varValue)) {
  418.             return true;
  419.         }
  421.         if (is_array($varValue)) {
  423.             return true;
  424.         }
  426.         if ($varValue && is_string($varValue)) {
  428.             return true;
  429.         }
  431.         return false;
  432.     }
  435.     public static function parseColumns($arrColumns)
  436.     {
  438.         $arrReturn = [];
  440.         if (!empty($arrColumns) && is_array($arrColumns)) {
  442.             foreach ($arrColumns as $arrColumn) {
  444.                 if ($arrColumn['name'] == 'PRIMARY' || $arrColumn['type'] == 'index') {
  446.                     continue;
  447.                 }
  449.                 $arrReturn[$arrColumn['name']] = $arrColumn['name'];
  450.             }
  451.         }
  453.         return $arrReturn;
  454.     }
  457.     public static function parseQueries($arrQueries, $fnCallback = null)
  458.     {
  460.         $arrReturn = [];
  462.         if (!empty($arrQueries) && is_array($arrQueries)) {
  464.             foreach ($arrQueries as $arrQuery) {
  466.                 if (in_array($arrQuery['operator'], self::$nullableOperators)) $arrQuery['allowEmptyValues'] = '1';
  468.                 if (!is_null($fnCallback) && is_callable($fnCallback)) $arrQuery = $fnCallback($arrQuery);
  470.                 $arrQuery = self::parseQuery($arrQuery);
  472.                 if (is_null($arrQuery)) continue;
  474.                 if (!empty($arrQuery['subQueries']) && is_array($arrQuery['subQueries'])) {
  476.                     $arrSubQueries = self::parseQueries($arrQuery['subQueries']);
  478.                     array_insert($arrSubQueries, 0, [[
  479.                         'field' => $arrQuery['field'],
  480.                         'value' => $arrQuery['value'],
  481.                         'operator' => $arrQuery['operator'],
  482.                     ]]);
  484.                     $arrReturn[] = $arrSubQueries;
  485.                 } else {
  487.                     $arrReturn[] = $arrQuery;
  488.                 }
  489.             }
  490.         }
  492.         return $arrReturn;
  493.     }
  496.     public static function isEmpty($varValue)
  497.     {
  499.         if (is_null($varValue) || $varValue === '') return true;
  501.         return false;
  502.     }
  505.     public static function parseQuery($arrQuery)
  506.     {
  508.         $blnAllowEmptyValue = isset($arrQuery['allowEmptyValues']) && $arrQuery['allowEmptyValues'];
  510.         if (isset($arrQuery['value']) && is_array($arrQuery['value'])) {
  512.             if (!empty($arrQuery['value'])) {
  513.                 foreach ($arrQuery['value'] as $strK => $strV) {
  514.                     $arrQuery['value'][$strK] = \Controller::replaceInsertTags($strV);
  515.                 }
  516.             }
  518.             if ($arrQuery['operator'] == 'between' && is_array($arrQuery['value'])) {
  520.                 if ($arrQuery['value'][0] === '' && $arrQuery['value'][1] === '') return null;
  521.                 if ($arrQuery['value'][0] === '') $arrQuery['value'][0] = '0';
  522.                 if ($arrQuery['value'][1] === '') {
  523.                     $numOff = (float)$arrQuery['value'][0];
  524.                     $arrQuery['value'][1] = $numOff * $numOff;
  525.                 }
  526.             }
  527.         }
  529.         if (isset($arrQuery['value']) && is_string($arrQuery['value'])) {
  531.             $arrQuery['value'] = \Controller::replaceInsertTags($arrQuery['value']);
  533.             if (strpos($arrQuery['value'], ',') && $arrQuery['operator'] != 'equal') {
  534.                 $arrQuery['value'] = explode(',', $arrQuery['value']);
  535.             }
  537.             if (is_string($arrQuery['value']) && $arrQuery['operator'] == 'regexp') {
  538.                 if (strpos($arrQuery['value'], ' ')) {
  539.                     $arrQuery['value'] = explode(' ', $arrQuery['value']);
  540.                 }
  541.             }
  542.         }
  544.         if (isset($arrQuery['value']) && is_array($arrQuery['value']) && !in_array($arrQuery['operator'], ['contain', 'notContain', 'between'])) {
  545.             $arrQuery['multiple'] = true;
  546.         }
  548.         if ((!isset($arrQuery['value']) || $arrQuery['value'] === '') && !$blnAllowEmptyValue) {
  549.             return null;
  550.         }
  552.         if ((is_array($arrQuery['value']) && empty($arrQuery['value'])) && !$blnAllowEmptyValue) {
  553.             return null;
  554.         }
  557.         if (is_numeric($arrQuery['value']) && in_array($arrQuery['operator'], ['lte', 'lt', 'gt', 'gte'])) {
  558.             if (strpos((string)$arrQuery['value'], '.') !== false) {
  559.                 $arrQuery['value'] = floatval($arrQuery['value']);
  560.             } else {
  561.                 $arrQuery['value'] = (int)$arrQuery['value'];
  562.             }
  563.         }
  565.         $arrQuery['value'] = self::prepareValueForQuery($arrQuery['value']);
  567.         return $arrQuery;
  568.     }
  571.     public static function returnOnlyExistedItems($arrItems, $arrExistedFields, $blnKeysOnly = false)
  572.     {
  574.         $arrReturn = [];
  575.         $arrExistedValues = $blnKeysOnly ? array_keys($arrExistedFields) : $arrExistedFields;
  577.         if (!empty($arrItems) && is_array($arrItems)) {
  579.             foreach ($arrItems as $varValue) {
  581.                 if (!$varValue || !is_string($varValue)) continue;
  583.                 if (!in_array($varValue, $arrExistedValues)) continue;
  585.                 $arrReturn[] = $varValue;
  586.             }
  587.         }
  589.         return $arrReturn;
  590.     }
  593.     public static function getRoutingParameter($strRoutingParameter, $blnEmptyArray = false)
  594.     {
  596.         $arrReturn = [];
  597.         $arrRoutingFragments = explode('/', $strRoutingParameter);
  599.         if (!empty($arrRoutingFragments) && is_array($arrRoutingFragments)) {
  601.             foreach ($arrRoutingFragments as $strRoutingFragment) {
  603.                 if (!$strRoutingFragment) continue;
  605.                 preg_match_all('/{(.*?)}/', $strRoutingFragment, $arrMatches);
  607.                 $strParamName = implode('', $arrMatches[1]);
  609.                 if ($strParamName) {
  611.                     $arrReturn[$strParamName] = $blnEmptyArray ? [] : $strParamName;
  612.                 }
  613.             }
  614.         }
  616.         return $arrReturn;
  617.     }
  620.     public static function parseMultipleOptions($varValue)
  621.     {
  623.         if (is_string($varValue)) {
  625.             $varValue = explode(',', $varValue);
  626.         }
  628.         return $varValue;
  629.     }
  632.     public static function isCoreTable($strTable)
  633.     {
  635.         return is_string($strTable) && substr($strTable, 0, 3) == 'tl_';
  636.     }
  639.     public static function getColumnsFromCoreTable($strTable, $blnFullContext = false)
  640.     {
  642.         $arrReturn = [];
  644.         \System::loadLanguageFile($strTable);
  645.         \Controller::loadDataContainer($strTable);
  647.         $arrFields = $GLOBALS['TL_DCA'][$strTable]['fields'];
  649.         if (!empty($arrFields) && is_array($arrFields)) {
  651.             foreach ($arrFields as $strFieldname => $arrField) {
  653.                 if (!isset($arrField['sql'])) continue;
  655.                 $varContext = $arrField;
  657.                 if (!$blnFullContext) {
  659.                     $strTitle = $strFieldname;
  661.                     if (is_array($arrField['label'])) {
  662.                         $varContext = $arrField['label'][0] ?: $strTitle;
  663.                     }
  664.                 }
  666.                 $arrReturn[$strFieldname] = $varContext;
  667.             }
  668.         }
  670.         return $arrReturn;
  671.     }
  674.     public static function parseCatalogValues($arrData, $arrFields = [], $blnJustStrings = false, $strJoinedTable = '')
  675.     {
  677.         if (!empty($arrData) && is_array($arrData)) {
  679.             foreach ($arrData as $strFieldname => $strOriginValue) {
  681.                 $strField = $strFieldname;
  683.                 if (Toolkit::isEmpty($strOriginValue)) continue;
  685.                 if ($strJoinedTable) {
  687.                     $strField = $strJoinedTable . ucfirst($strFieldname);
  688.                 }
  690.                 $arrField = $arrFields[$strField] ?? null;
  692.                 if (is_null($arrField)) continue;
  693.                 if (!isset($arrField['type']) || !$arrField['type']) continue;
  695.                 $varValue = static::parseCatalogValue($strOriginValue, $arrField, $arrData);
  697.                 if ($blnJustStrings) {
  698.                     if (is_array($varValue) && $arrField['type'] != 'upload') {
  699.                         $varValue = implode(', ', $varValue);
  700.                     }
  701.                     if (is_array($varValue) && $arrField['type'] == 'upload') {
  702.                         if (isset($varValue[0])) {
  703.                             $varValue = $varValue[0]['singleSRC'];
  704.                         } else {
  705.                             $varValue = $varValue['singleSRC'];
  706.                         }
  707.                     }
  708.                 }
  710.                 $arrData[$strFieldname] = Toolkit::isEmpty($varValue) ? $strOriginValue : $varValue;
  711.             }
  712.         }
  714.         return $arrData;
  715.     }
  718.     public static function parseCatalogValue($strValue, $arrField, $arrData = [])
  719.     {
  721.         switch ($arrField['type']) {
  723.             case 'upload':
  725.                 $blnFrontend = TL_MODE == 'FE' || $arrField['useArrayFormat'];
  726.                 if ($blnFrontend) {
  727.                     $strValue = Upload::parseValue($strValue, $arrField, $arrData);
  728.                     if (is_array($strValue) && $arrField['fileType'] == 'gallery') {
  729.                         if ($strValue['preview']) $arrData[$arrField['fieldname'] . 'Preview'] = $strValue['preview'];
  730.                         $strValue = $strValue['gallery'];
  731.                     }
  732.                 } else {
  733.                     $strValue = Upload::parseThumbnails($strValue, $arrField, $arrData);
  734.                 }
  736.                 break;
  738.             case 'select':
  740.                 $strValue = Select::parseValue($strValue, $arrField, $arrData);
  742.                 break;
  744.             case 'checkbox':
  746.                 $strValue = Checkbox::parseValue($strValue, $arrField, $arrData);
  748.                 break;
  750.             case 'radio':
  752.                 $strValue = Radio::parseValue($strValue, $arrField, $arrData);
  754.                 break;
  756.             case 'date':
  758.                 $strValue = DateInput::parseValue($strValue, $arrField, $arrData);
  760.                 break;
  762.             case 'number':
  764.                 $strValue = Number::parseValue($strValue, $arrField, $arrData);
  766.                 break;
  768.             case 'textarea':
  770.                 $strValue = Textarea::parseValue($strValue, $arrField, $arrData);
  772.                 break;
  774.             case 'dbColumn':
  776.                 $strValue = DbColumn::parseValue($strValue, $arrField, $arrData);
  778.                 break;
  779.         }
  781.         return $strValue;
  782.     }
  785.     public static function createPanelLayout($arrPanelLayout)
  786.     {
  788.         $arrPanelLayout = is_array($arrPanelLayout) ? $arrPanelLayout : [];
  789.         $strPanelLayout = implode(',', $arrPanelLayout);
  791.         if (strpos($strPanelLayout, 'filter') !== false) {
  793.             $strPanelLayout = preg_replace('/,/', ';', $strPanelLayout, 1);
  794.         }
  796.         return $strPanelLayout;
  797.     }
  800.     public static function getLabelValue($varValue, $strFallback)
  801.     {
  803.         if (Toolkit::isEmpty($varValue)) return $strFallback;
  804.         if (is_array($varValue)) return $varValue[0] ?: '';
  805.         if (is_string($varValue)) return $varValue ?: '';
  807.         return $strFallback;
  808.     }
  811.     public static function getBackendModuleTablesByDoAttribute($strDo)
  812.     {
  814.         if (is_array($GLOBALS['BE_MOD']) && TL_MODE == 'BE' && !Toolkit::isEmpty($strDo)) {
  816.             foreach ($GLOBALS['BE_MOD'] as $arrModules) {
  818.                 foreach ($arrModules as $strModulename => $arrModule) {
  820.                     if ($strModulename == $strDo) {
  822.                         return is_array($arrModule['tables']) ? $arrModule['tables'] : [];
  823.                     }
  824.                 }
  825.             }
  826.         }
  828.         return [];
  829.     }
  832.     public static function strictMode()
  833.     {
  835.         if (!isset($GLOBALS['TL_CONFIG']['ctlg_strict_mode']) || !is_bool($GLOBALS['TL_CONFIG']['ctlg_strict_mode'])) return true;
  837.         return $GLOBALS['TL_CONFIG']['ctlg_strict_mode'] ? true : false;
  838.     }
  841.     public static function ignoreRomanization()
  842.     {
  844.         if (!isset($GLOBALS['TL_CONFIG']['ctlg_ignore_romanization']) || !is_bool($GLOBALS['TL_CONFIG']['ctlg_ignore_romanization'])) return false;
  846.         return $GLOBALS['TL_CONFIG']['ctlg_ignore_romanization'] ? true : false;
  847.     }
  850.     public static function dump($varDump)
  851.     {
  853.         echo '<pre>' . var_export($varDump, true) . '</pre>';
  854.     }
  857.     public static function flatter($arrValues, &$arrFlattedArray = [])
  858.     {
  860.         foreach ($arrValues as $strKey => $varValue) {
  862.             if (is_array($varValue)) {
  864.                 static::flatter($varValue, $arrFlattedArray);
  865.                 continue;
  866.             }
  868.             $arrFlattedArray[] = [
  870.                 'key' => $strKey,
  871.                 'value' => $varValue
  872.             ];
  873.         }
  875.         return $arrFlattedArray;
  876.     }
  879.     public static function hasDynAlias()
  880.     {
  882.         return is_bool(\Config::get('dynAlias')) && \Config::get('dynAlias') === true;
  883.     }
  886.     public static function setTokens($arrRow, $strName, &$arrTokens = [])
  887.     {
  889.         foreach ($arrRow as $strFieldname => $strValue) {
  891.             $arrTokens[$strName . $strFieldname] = $strValue;
  892.         }
  894.         return $arrTokens;
  895.     }
  898.     public static function parsePseudoInserttag($strValue = '', $arrData = [])
  899.     {
  901.         if (!empty($strValue) && is_string($strValue) && strpos($strValue, '{{') !== false) {
  903.             $arrTags = preg_split('/{{(([^{}]*|(?R))*)}}/', $strValue, -1, PREG_SPLIT_DELIM_CAPTURE);
  904.             $strTag = implode('', $arrTags);
  906.             if ($strTag && isset($arrData) && is_array($arrData)) {
  908.                 return Toolkit::isEmpty($arrData[$strTag]) ? '' : $arrData[$strTag];
  909.             }
  910.         }
  912.         return $strValue;
  913.     }
  916.     public static function flatterWithoutKeyValue($arrValues, &$arrReturn, $strPrefix = '')
  917.     {
  919.         if (is_array($arrValues) && !empty($arrValues)) {
  921.             foreach ($arrValues as $strField => $varValue) {
  923.                 if (is_array($varValue)) {
  925.                     static::flatterWithoutKeyValue($varValue, $arrReturn, $strField);
  926.                 } else {
  928.                     $arrReturn[($strPrefix ? $strPrefix . '_' : '') . $strField] = $varValue;
  929.                 }
  930.             }
  931.         }
  932.     }
  935.     public static function getIcon($strType)
  936.     {
  938.         return $GLOBALS['CM_ICON_SET'][$strType];
  939.     }
  942.     public static function slug($strValue, $arrOptions = [])
  943.     {
  945.         $strValue = \StringUtil::generateAlias($strValue);
  947.         if (version_compare(VERSION, '3.5', '>') && class_exists('Ausi\SlugGenerator\SlugGenerator') && !Toolkit::ignoreRomanization()) {
  949.             $strDelimiter = '-';
  951.             if (isset($arrOptions['delimiter']) && $arrOptions['delimiter']) {
  953.                 $strDelimiter = $arrOptions['delimiter'];
  954.             }
  956.             $objSlugGenerator = new \Ausi\SlugGenerator\SlugGenerator((new \Ausi\SlugGenerator\SlugOptions)
  957.                 ->setValidChars('a-zA-Z0-9')
  958.                 ->setLocale('de')
  959.                 ->setDelimiter($strDelimiter)
  960.             );
  962.             $strValue = $objSlugGenerator->generate($strValue);
  963.         }
  965.         return $strValue;
  966.     }
  969.     public static function getEntityUrl($strModuleId, $strEntityId)
  970.     {
  972.         $objDatabase = \Database::getInstance();
  973.         $objModule = $objDatabase->prepare('SELECT * FROM tl_module WHERE id = ?')->limit(1)->execute($strModuleId);
  975.         if (!$objModule->catalogTablename || !$objModule->catalogUseMasterPage || !$objModule->catalogMasterPage) {
  977.             return '';
  978.         }
  980.         $objEntity = $objDatabase->prepare('SELECT * FROM ' . $objModule->catalogTablename . ' WHERE id = ?')->limit(1)->execute($strEntityId);
  982.         if (!$objEntity->alias) {
  984.             return '';
  985.         }
  987.         $objPage = \PageModel::findByPk($objModule->catalogMasterPage);
  989.         if ($objPage == null) {
  991.             return '';
  992.         }
  994.         if ($objPage->catalogUseRouting && $objPage->catalogRouting) {
  996.             $objEntity->alias = static::generateAliasWithRouting($objEntity->alias, static::getRoutingParameter($objPage->catalogRouting), $objEntity->row());
  997.         }
  999.         return \Controller::generateFrontendUrl($objPage->row(), ($objEntity->alias ? '/' . $objEntity->alias : ''));
  1000.     }
  1003.     public static function generateAliasWithRouting($strAlias, $arrRoutingParameter, $arrCatalog = [])
  1004.     {
  1006.         $strAliasWithFragments = '';
  1008.         if (!in_array('auto_item', $arrRoutingParameter)) {
  1010.             return $strAlias;
  1011.         }
  1013.         $intIndex = 0;
  1014.         $intTotal = count($arrRoutingParameter) - 1;
  1015.         $blnAutoItem = in_array('auto_item', $arrRoutingParameter);
  1017.         foreach ($arrRoutingParameter as $strParameter) {
  1019.             ++$intIndex;
  1021.             if ($strParameter === 'auto_item') {
  1023.                 if (Toolkit::isEmpty($strAlias)) continue;
  1025.                 $strAliasWithFragments .= '/' . $strAlias;
  1027.                 continue;
  1028.             }
  1030.             if (!Toolkit::isEmpty($arrCatalog[$strParameter])) {
  1032.                 $strAliasWithFragments .= $arrCatalog[$strParameter] . ($intIndex != $intTotal && $blnAutoItem ? '/' : '');
  1033.             } else {
  1035.                 $strAliasWithFragments .= ' ' . ($intIndex != $intTotal && $blnAutoItem ? '/' : '');
  1036.             }
  1037.         }
  1039.         if ($strAliasWithFragments) {
  1041.             $strAlias = $strAliasWithFragments;
  1042.         }
  1044.         return $strAlias;
  1045.     }
  1048.     public static function generateDynValue($strSimpleTokens, $arrValues)
  1049.     {
  1051.         return \StringUtil::parseSimpleTokens($strSimpleTokens, $arrValues);
  1052.     }
  1053. }