vendor/isotope/isotope-core/system/modules/isotope/library/Isotope/Model/Attribute.php line 447

Open in your IDE?
  1. <?php
  3. /*
  4.  * Isotope eCommerce for Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2009 - 2019 terminal42 gmbh & Isotope eCommerce Workgroup
  7.  *
  8.  * @link       https://isotopeecommerce.org
  9.  * @license    https://opensource.org/licenses/lgpl-3.0.html
  10.  */
  12. namespace Isotope\Model;
  14. use Contao\ArrayUtil;
  15. use Contao\Controller;
  16. use Contao\Database;
  17. use Contao\FilesModel;
  18. use Contao\Model;
  19. use Contao\StringUtil;
  20. use Haste\Util\Format;
  21. use Isotope\Interfaces\IsotopeAttribute;
  22. use Isotope\Interfaces\IsotopeAttributeWithOptions;
  23. use Isotope\Interfaces\IsotopeProduct;
  24. use Isotope\Isotope;
  25. use Isotope\Translation;
  28. /**
  29.  * Attribute represents a product attribute in Isotope eCommerce
  30.  *
  31.  * @property int           $id
  32.  * @property int           $tstamp
  33.  * @property string        $name
  34.  * @property string        $field_name
  35.  * @property string        $type
  36.  * @property string        $legend
  37.  * @property string        $description
  38.  * @property string        $optionsSource
  39.  * @property string|array  $options
  40.  * @property string        $foreignKey
  41.  * @property bool          $includeBlankOption
  42.  * @property string        $blankOptionLabel
  43.  * @property bool          $variant_option
  44.  * @property bool          $customer_defined
  45.  * @property bool          $be_search
  46.  * @property bool          $be_filter
  47.  * @property bool          $mandatory
  48.  * @property bool          $fe_filter
  49.  * @property bool          $fe_search
  50.  * @property bool          $fe_sorting
  51.  * @property bool          $multiple
  52.  * @property int           $size
  53.  * @property string        $extensions
  54.  * @property string        $rte
  55.  * @property bool          $multilingual
  56.  * @property bool          $rgxp
  57.  * @property bool          $placeholder
  58.  * @property int           $minlength
  59.  * @property int           $maxlength
  60.  * @property string        $conditionField
  61.  * @property string        $fieldType
  62.  * @property bool          $files
  63.  * @property bool          $filesOnly
  64.  * @property string        $sortBy
  65.  * @property string        $path
  66.  * @property bool          $storeFile
  67.  * @property string        $uploadFolder
  68.  * @property bool          $useHomeDir
  69.  * @property bool          $doNotOverwrite
  70.  * @property bool          $checkoutRelocate
  71.  * @property string        $checkoutTargetFolder
  72.  * @property string        $checkoutTargetFile
  73.  * @property bool          $datepicker
  74.  */
  75. abstract class Attribute extends TypeAgent implements IsotopeAttribute
  76. {
  78.     /**
  79.      * Table name
  80.      * @var string
  81.      */
  82.     protected static $strTable = 'tl_iso_attribute';
  84.     /**
  85.      * Interface to validate attribute
  86.      * @var string
  87.      */
  88.     protected static $strInterface = '\Isotope\Interfaces\IsotopeAttribute';
  90.     /**
  91.      * List of types (classes) for this model
  92.      * @var array
  93.      */
  94.     protected static $arrModelTypes = array();
  96.     /**
  97.      * Holds a map for field name to ID
  98.      * @var array
  99.      */
  100.     protected static $arrFieldNameMap = array();
  102.     /**
  103.      * Options for variants cache
  104.      * @var array
  105.      */
  106.     private $arrOptionsForVariants = array();
  108.     /**
  109.      * Return true if attribute is a variant option
  110.      *
  111.      * @return bool
  112.      *
  113.      * @deprecated will only be available when IsotopeAttributeForVariants interface is implemented
  114.      */
  115.     public function isVariantOption()
  116.     {
  117.         return (bool) $this->variant_option;
  118.     }
  120.     /**
  121.      * @inheritdoc
  122.      */
  123.     public function getFieldName()
  124.     {
  125.         return $this->field_name;
  126.     }
  128.     /**
  129.      * @inheritdoc
  130.      */
  131.     public function isCustomerDefined()
  132.     {
  133.         /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  134.         if ($this->isVariantOption()) {
  135.             return false;
  136.         }
  138.         return (bool) $this->customer_defined;
  139.     }
  141.     /**
  142.      * @inheritdoc
  143.      */
  144.     public function getBackendWidget()
  145.     {
  146.         if (!isset($GLOBALS['BE_FFL'][$this->type])) {
  147.             throw new \LogicException('Backend widget for attribute type "' . $this->type . '" does not exist.');
  148.         }
  150.         return $GLOBALS['BE_FFL'][$this->type];
  151.     }
  153.     /**
  154.      * @inheritdoc
  155.      */
  156.     public function getFrontendWidget()
  157.     {
  158.         if (!isset($GLOBALS['TL_FFL'][$this->type])) {
  159.             throw new \LogicException('Frontend widget for attribute type "' . $this->type . '" does not exist.');
  160.         }
  162.         return $GLOBALS['TL_FFL'][$this->type];
  163.     }
  165.     /**
  166.      * @inheritdoc
  167.      */
  168.     public function loadFromDCA(array &$arrData, $strName)
  169.     {
  170.         $arrField = &$arrData['fields'][$strName];
  172.         $this->arrData = \is_array($arrField['attributes']) ? $arrField['attributes'] : array();
  174.         if (\is_array($arrField['eval'] ?? null)) {
  175.             $this->arrData = array_merge($arrField['eval'], $this->arrData);
  176.         }
  178.         $this->field_name  = $strName;
  179.         $this->type        = array_search(\get_called_class(), static::getModelTypes(), true);
  180.         $this->name        = \is_array($arrField['label'] ?? null) ? $arrField['label'][0] : ($arrField['label'] ?? $strName);
  181.         $this->description = \is_array($arrField['label'] ?? null) ? $arrField['label'][1] : '';
  182.         $this->be_filter   = ($arrField['filter'] ?? false) ? '1' : '';
  183.         $this->be_search   = ($arrField['search'] ?? false) ? '1' : '';
  184.         $this->foreignKey  = $arrField['foreignKey'] ?? null;
  185.         $this->optionsSource = '';
  186.     }
  188.     /**
  189.      * @inheritdoc
  190.      */
  191.     public function saveToDCA(array &$arrData)
  192.     {
  193.         // Keep field settings made through DCA code
  194.         $arrField = \is_array($arrData['fields'][$this->field_name] ?? null) ? $arrData['fields'][$this->field_name] : [];
  196.         $arrField['label']                          = Translation::get(array($this->name, $this->description));
  197.         $arrField['exclude']                        = true;
  198.         $arrField['inputType']                      = '';
  199.         $arrField['attributes']                     = $this->row();
  200.         $arrField['attributes']['variant_option']   = $this->isVariantOption(); /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  201.         $arrField['attributes']['customer_defined'] = $this->isCustomerDefined();
  202.         $arrField['eval']                           = \is_array($arrField['eval'] ?? null) ? array_merge($arrField['eval'], $arrField['attributes']) : $arrField['attributes'];
  204.         if ('' !== (string) $this->placeholder) {
  205.             $arrField['eval']['placeholder'] = Translation::get($this->placeholder);
  206.         }
  208.         if (!$this->isCustomerDefined()) {
  209.             $arrField['inputType'] = (string) array_search($this->getBackendWidget(), $GLOBALS['BE_FFL'], true);
  210.         }
  212.         // Support numeric paths (fileTree)
  213.         unset($arrField['eval']['path']);
  214.         if ($this->path != '' && ($objFile = FilesModel::findByPk($this->path)) !== null) {
  215.             $arrField['eval']['path'] = $objFile->path;
  216.         }
  218.         // Only enable RTE config in the TextArea attribute
  219.         unset($arrField['eval']['rte']);
  221.         if ($this->be_filter) {
  222.             $arrField['filter'] = true;
  223.         }
  225.         if ($this->be_search) {
  226.             $arrField['search'] = true;
  227.         }
  229.         // Variant selection is always mandatory
  230.         /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  231.         if ($this->isVariantOption()) {
  232.             $arrField['eval']['mandatory'] = true;
  233.         }
  235.         if ($this->blankOptionLabel != '') {
  236.             $arrField['eval']['blankOptionLabel'] = Translation::get($this->blankOptionLabel);
  237.         }
  239.         // Prepare options
  240.         if (IsotopeAttributeWithOptions::SOURCE_FOREIGNKEY === $this->optionsSource && !$this->isVariantOption()) {
  241.             $arrField['foreignKey'] = $this->parseForeignKey($this->foreignKey, $GLOBALS['TL_LANGUAGE']);
  242.             unset($arrField['options'], $arrField['reference']);
  244.         } else {
  245.             $arrOptions = null;
  247.             switch ($this->optionsSource) {
  248.                 case IsotopeAttributeWithOptions::SOURCE_ATTRIBUTE:
  249.                     $arrOptions = StringUtil::deserialize($this->options);
  250.                     break;
  252.                 case IsotopeAttributeWithOptions::SOURCE_FOREIGNKEY:
  253.                     $foreignKey = $this->parseForeignKey($this->foreignKey, $GLOBALS['TL_LANGUAGE']);
  254.                     $arrKey     = explode('.', $foreignKey, 2);
  256.                     if ('' !== (string) $arrKey[0] && '' !== $arrKey[1]) {
  257.                         $arrOptions = Database::getInstance()
  258.                             ->execute("SELECT id AS value, {$arrKey[1]} AS label FROM {$arrKey[0]} ORDER BY label")
  259.                             ->fetchAllAssoc()
  260.                         ;
  261.                     }
  262.                     break;
  264.                 case IsotopeAttributeWithOptions::SOURCE_TABLE:
  265.                     $arrOptions = [];
  266.                     if ($this instanceof IsotopeAttributeWithOptions && null !== ($options = AttributeOption::findByAttribute($this, ['order' => AttributeOption::getTable().'.label']))) {
  267.                         foreach ($options as $model) {
  268.                             $arrOptions[] = [
  269.                                 'value' => $model->getLanguageId(),
  270.                                 'label' => $model->label,
  271.                             ];
  272.                         }
  273.                     }
  274.                     break;
  276.                 case IsotopeAttributeWithOptions::SOURCE_PRODUCT:
  277.                     $arrOptions = [];
  278.                     if ($this instanceof IsotopeAttributeWithOptions && null !== ($options = AttributeOption::findByProducts($this, ['order' => AttributeOption::getTable().'.label']))) {
  279.                         foreach ($options as $model) {
  280.                             $arrOptions[] = [
  281.                                 'value' => $model->getLanguageId(),
  282.                                 'label' => $model->label,
  283.                             ];
  284.                         }
  285.                     }
  286.                     break;
  288.                 default:
  289.                     if ($this instanceof IsotopeAttributeWithOptions) {
  290.                         unset($arrField['options'], $arrField['reference']);
  291.                     }
  292.             }
  294.             if (!empty($arrOptions) && \is_array($arrOptions)) {
  295.                 $arrField['default'] = array();
  296.                 $arrField['options'] = array();
  297.                 $arrField['eval']['isAssociative'] = true;
  298.                 unset($arrField['reference']);
  299.                 $strGroup = '';
  301.                 foreach ($arrOptions as $option) {
  302.                     if ($option['group'] ?? false) {
  303.                         $strGroup = Translation::get($option['label']);
  304.                         continue;
  305.                     }
  307.                     if ($strGroup != '') {
  308.                         $arrField['options'][$strGroup][$option['value']] = Translation::get($option['label']);
  309.                     } else {
  310.                         $arrField['options'][$option['value']] = Translation::get($option['label']);
  311.                     }
  313.                     if ($option['default'] ?? false) {
  314.                         $arrField['default'][] = $option['value'];
  315.                     }
  316.                 }
  318.                 if (empty($arrField['default']) || $this->isCustomerDefined()) {
  319.                     unset($arrField['default']);
  320.                 } else if (!$arrField['eval']['multiple']) {
  321.                     $arrField['default'] = reset($arrField['default']);
  322.                 }
  323.             }
  324.         }
  326.         unset($arrField['eval']['foreignKey'], $arrField['eval']['options']);
  328.         // Add field to the current DCA table
  329.         $arrData['fields'][$this->field_name] = $arrField;
  330.     }
  332.     /**
  333.      * Get field options
  334.      * @return  array
  335.      * @deprecated  will only be available when IsotopeAttributeWithOptions interface is implemented
  336.      */
  337.     public function getOptions()
  338.     {
  339.         $arrOptions = StringUtil::deserialize($this->options);
  341.         if (!\is_array($arrOptions)) {
  342.             return array();
  343.         }
  345.         return $arrOptions;
  346.     }
  348.     /**
  349.      * Get available variant options for a product
  350.      *
  351.      * @param int[] $arrIds
  352.      * @param array $arrOptions
  353.      *
  354.      * @return array
  355.      * @deprecated will only be available when IsotopeAttributeForVariants interface is implemented
  356.      */
  357.     public function getOptionsForVariants(array $arrIds, array $arrOptions = array())
  358.     {
  359.         if (0 === \count($arrIds)) {
  360.             return [];
  361.         }
  363.         sort($arrIds);
  364.         ksort($arrOptions);
  365.         $strKey = md5(implode('-', $arrIds) . '_' . json_encode($arrOptions));
  367.         if (!isset($this->arrOptionsForVariants[$strKey])) {
  368.             $strWhere = '';
  370.             foreach ($arrOptions as $field => $value) {
  371.                 $strWhere .= " AND $field=?";
  372.             }
  374.             $this->arrOptionsForVariants[$strKey] = Database::getInstance()->prepare('
  375.                 SELECT DISTINCT ' . $this->field_name . ' FROM tl_iso_product WHERE id IN (' . implode(',', $arrIds) . ')
  376.                 ' . $strWhere
  377.             )->execute($arrOptions)->fetchEach($this->field_name);
  378.         }
  380.         return $this->arrOptionsForVariants[$strKey];
  381.     }
  383.     /**
  384.      * @inheritdoc
  385.      */
  386.     public function getValue(IsotopeProduct $product)
  387.     {
  388.         return $product->{$this->field_name};
  389.     }
  391.     /**
  392.      * @inheritdoc
  393.      */
  394.     public function getLabel()
  395.     {
  396.         return Format::dcaLabel('tl_iso_product', $this->field_name);
  397.     }
  399.     /**
  400.      * Generate HTML markup of product data for this attribute
  401.      *
  402.      * @param IsotopeProduct $objProduct
  403.      * @param array          $arrOptions
  404.      *
  405.      * @return mixed
  406.      */
  407.     public function generate(IsotopeProduct $objProduct, array $arrOptions = array())
  408.     {
  409.         $varValue = $this->getValue($objProduct);
  410.         $arrOptions['product'] = $objProduct;
  412.         if (!\is_array($varValue)) {
  413.             return $this->generateValue($varValue, $arrOptions);
  414.         }
  416.         // Generate a HTML table for associative arrays
  417.         if (!ArrayUtil::isAssoc($varValue) && \is_array($varValue[0])) {
  418.             return ($arrOptions['noHtml'] ?? false) ? $varValue : $this->generateTable($varValue, $objProduct);
  419.         }
  421.         if ($arrOptions['noHtml'] ?? false) {
  422.             $result = array();
  424.             foreach ($varValue as $v1) {
  425.                 $result[$v1] = $this->generateValue($v1, $arrOptions);
  426.             }
  428.             return $result;
  429.         }
  431.         // Generate ul/li listing for simple arrays
  432.         foreach ($varValue as &$v2) {
  433.             $v2 = $this->generateValue($v2, $arrOptions);
  434.         }
  436.         return $this->generateList($varValue);
  437.     }
  439.     /**
  440.      * @param mixed $value
  441.      * @param array $options
  442.      *
  443.      * @return string
  444.      */
  445.     public function generateValue($value, array $options = [])
  446.     {
  447.         return Format::dcaValue('tl_iso_product', $this->field_name, $value);
  448.     }
  450.     /**
  451.      * Returns the foreign key for a certain language with a fallback option
  452.      *
  453.      * @param string $strSettings
  454.      * @param bool   $strLanguage
  455.      *
  456.      * @return mixed
  457.      */
  458.     protected function parseForeignKey($strSettings, $strLanguage = false)
  459.     {
  460.         $strFallback = null;
  461.         $arrLines    = StringUtil::trimsplit('@\r\n|\n|\r@', $strSettings);
  463.         // Return false if there are no lines
  464.         if ($strSettings == '' || !\is_array($arrLines) || empty($arrLines)) {
  465.             return null;
  466.         }
  468.         // Loop over the lines
  469.         foreach ($arrLines as $strLine) {
  470.             // Ignore empty lines and comments
  471.             if ($strLine == '' || strpos($strLine, '#') === 0) {
  472.                 continue;
  473.             }
  475.             // Check for a language1
  476.             if (preg_match('/^([a-z]{2}(-[A-Z]{2})?)=(.+)$/', $strLine, $matches)) {
  477.                 $foreignKey = $matches[3];
  479.                 if ($matches[1] === $strLanguage) {
  480.                     return $foreignKey;
  481.                 }
  483.                 if (null === $strFallback) {
  484.                     $strFallback = $foreignKey;
  485.                 }
  486.             } elseif (null === $strFallback) {
  487.                 // The row without language is the fallback
  488.                 $strFallback = $strLine;
  489.             }
  490.         }
  492.         return $strFallback;
  493.     }
  495.     /**
  496.      * Generate HTML table for associative array values
  497.      *
  498.      * @param array          $arrValues
  499.      * @param IsotopeProduct $objProduct
  500.      *
  501.      * @return string
  502.      */
  503.     protected function generateTable(array $arrValues, IsotopeProduct $objProduct)
  504.     {
  505.         $arrFormat = $GLOBALS['TL_DCA']['tl_iso_product']['fields'][$this->field_name]['tableformat'];
  507.         $last = \count($arrValues[0]) - 1;
  509.         $strBuffer = '
  510. <table class="' . $this->field_name . '">
  511.   <thead>
  512.     <tr>';
  514.         foreach (array_keys($arrValues[0]) as $i => $name) {
  515.             if ($arrFormat[$name]['doNotShow']) {
  516.                 continue;
  517.             }
  519.             $label = $arrFormat[$name]['label'] ?: $name;
  521.             $strBuffer .= '
  522.       <th class="head_' . $i . ($i == 0 ? ' head_first' : '') . ($i == $last ? ' head_last' : '') . (!is_numeric($name) ? ' ' . StringUtil::standardize($name) : '') . '">' . $label . '</th>';
  523.         }
  525.         $strBuffer .= '
  526.     </tr>
  527.   </thead>
  528.   <tbody>';
  530.         foreach ($arrValues as $r => $row) {
  531.             $strBuffer .= '
  532.     <tr class="row_' . $r . ($r == 0 ? ' row_first' : '') . ($r == $last ? ' row_last' : '') . ' ' . ($r % 2 ? 'odd' : 'even') . '">';
  534.             $c = -1;
  536.             foreach ($row as $name => $value) {
  537.                 if ($arrFormat[$name]['doNotShow']) {
  538.                     continue;
  539.                 }
  541.                 if ('price' === $arrFormat[$name]['rgxp']) {
  542.                     $intTax = (int) $row['tax_class'];
  544.                     $value = Isotope::formatPriceWithCurrency(Isotope::calculatePrice($value, $objProduct, $this->field_name, $intTax));
  545.                 } else {
  546.                     $value = $arrFormat[$name]['format'] ? sprintf($arrFormat[$name]['format'], $value) : $value;
  547.                 }
  549.                 $strBuffer .= '
  550.       <td class="col_' . ++$c . ($c == 0 ? ' col_first' : '') . ($c == $last ? ' col_last' : '') . ' ' . StringUtil::standardize($name) . '">' . $value . '</td>';
  551.             }
  553.             $strBuffer .= '
  554.     </tr>';
  555.         }
  557.         $strBuffer .= '
  558.   </tbody>
  559. </table>';
  561.         return $strBuffer;
  562.     }
  564.     /**
  565.      * Generate HTML list for array values
  566.      *
  567.      * @param array $arrValues
  568.      *
  569.      * @return string
  570.      */
  571.     protected function generateList(array $arrValues)
  572.     {
  573.         $strBuffer = "\n<ul>";
  575.         $current = 0;
  576.         $last    = \count($arrValues) - 1;
  577.         foreach ($arrValues as $value) {
  578.             $class = trim(($current == 0 ? 'first' : '') . ($current == $last ? ' last' : ''));
  580.             $strBuffer .= "\n<li" . ($class != '' ? ' class="' . $class . '"' : '') . '>' . $value . '</li>';
  582.             ++$current;
  583.         }
  585.         $strBuffer .= "\n</ul>";
  587.         return $strBuffer;
  588.     }
  590.     /**
  591.      * Get list of system columns
  592.      *
  593.      * @return array
  594.      */
  595.     public static function getSystemColumnsFields()
  596.     {
  597.         static $arrFields;
  599.         if (null === $arrFields) {
  600.             Controller::loadDataContainer('tl_iso_product');
  602.             $arrFields = array();
  603.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  605.             foreach ($arrDCA as $field => $config) {
  606.                 if ($config['attributes']['systemColumn']) {
  607.                     $arrFields[] = $field;
  608.                 }
  609.             }
  610.         }
  612.         return $arrFields;
  613.     }
  615.     /**
  616.      * Return list of variant option fields
  617.      *
  618.      * @return array
  619.      */
  620.     public static function getVariantOptionFields()
  621.     {
  622.         static $arrFields;
  624.         if (null === $arrFields) {
  625.             Controller::loadDataContainer('tl_iso_product');
  627.             $arrFields = array();
  628.             $arrAttributes = &$GLOBALS['TL_DCA']['tl_iso_product']['attributes'];
  630.             /** @var Attribute $objAttribute */
  631.             foreach ($arrAttributes as $field => $objAttribute) {
  632.                 /* @todo in 3.0: $objAttribute instanceof IsotopeAttributeForVariants */
  633.                 if ($objAttribute->isVariantOption()) {
  634.                     $arrFields[] = $field;
  635.                 }
  636.             }
  637.         }
  639.         return $arrFields;
  640.     }
  642.     /**
  643.      * Return list of fields that are customer defined
  644.      *
  645.      * @return array
  646.      */
  647.     public static function getCustomerDefinedFields()
  648.     {
  649.         static $arrFields;
  651.         if (null === $arrFields) {
  652.             Controller::loadDataContainer('tl_iso_product');
  654.             $arrFields = array();
  655.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  657.             foreach ($arrDCA as $field => $config) {
  658.                 if ($config['attributes']['customer_defined'] ?? false) {
  659.                     $arrFields[] = $field;
  660.                 }
  661.             }
  662.         }
  664.         return $arrFields;
  665.     }
  667.     /**
  668.      * Return array of attributes that have price relevant information
  669.      *
  670.      * @return array
  671.      */
  672.     public static function getPricedFields()
  673.     {
  674.         static $arrFields;
  676.         if (null === $arrFields) {
  677.             $arrFields = Database::getInstance()->query("
  678.                 SELECT a.field_name
  679.                 FROM tl_iso_attribute a
  680.                 JOIN tl_iso_attribute_option o ON a.id=o.pid
  681.                 WHERE
  682.                   a.optionsSource='table'
  683.                   AND o.ptable='tl_iso_attribute'
  684.                   AND o.published='1'
  685.                   AND o.price!=''
  687.                 UNION
  689.                 SELECT a.field_name
  690.                 FROM tl_iso_attribute a
  691.                 JOIN tl_iso_attribute_option o ON a.field_name=o.field_name
  692.                 WHERE
  693.                   a.optionsSource='product'
  694.                   AND o.ptable='tl_iso_product'
  695.                   AND o.published='1'
  696.                   AND o.price!=''
  697.             ")->fetchEach('field_name');
  698.         }
  700.         return $arrFields;
  701.     }
  703.     /**
  704.      * Return list of fields that are multilingual
  705.      *
  706.      * @return array
  707.      */
  708.     public static function getMultilingualFields()
  709.     {
  710.         static $arrFields;
  712.         if (null === $arrFields) {
  713.             Controller::loadDataContainer('tl_iso_product');
  715.             $arrFields = array();
  716.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  718.             foreach ($arrDCA as $field => $config) {
  719.                 if ($config['attributes']['multilingual'] ?? null) {
  720.                     $arrFields[] = $field;
  721.                 }
  722.             }
  723.         }
  725.         return $arrFields;
  726.     }
  728.     /**
  729.      * Return list of fields that have fetch_fallback set
  730.      *
  731.      * @return array
  732.      */
  733.     public static function getFetchFallbackFields()
  734.     {
  735.         static $arrFields;
  737.         if (null === $arrFields) {
  738.             Controller::loadDataContainer('tl_iso_product');
  740.             $arrFields = array();
  741.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  743.             foreach ($arrDCA as $field => $config) {
  744.                 if ($config['attributes']['fetch_fallback'] ?? null) {
  745.                     $arrFields[] = $field;
  746.                 }
  747.             }
  748.         }
  750.         return $arrFields;
  751.     }
  753.     /**
  754.      * Return list of dynamic fields
  755.      * Dynamic fields cannot be filtered on database level (e.g. product price)
  756.      *
  757.      * @return array
  758.      */
  759.     public static function getDynamicAttributeFields()
  760.     {
  761.         static $arrFields;
  763.         if (null === $arrFields) {
  764.             Controller::loadDataContainer('tl_iso_product');
  766.             $arrFields = array();
  767.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  769.             foreach ($arrDCA as $field => $config) {
  770.                 if (($config['attributes']['dynamic'] ?? null)
  771.                     || (($config['eval']['multiple'] ?? null) && !($config['eval']['csv'] ?? null))
  772.                 ) {
  773.                     $arrFields[] = $field;
  774.                 }
  775.             }
  776.         }
  778.         return $arrFields;
  779.     }
  781.     /**
  782.      * Return list of fixed fields
  783.      * Fixed fields cannot be disabled in product type config
  784.      *
  785.      * @param string|null $class
  786.      *
  787.      * @return array
  788.      */
  789.     public static function getFixedFields($class = null)
  790.     {
  791.         Controller::loadDataContainer('tl_iso_product');
  793.         $arrFields = array();
  794.         $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  796.         foreach ($arrDCA as $field => $config) {
  797.             $fixed = ($config['attributes']['fixed'] ?? null);
  798.             $isArray = \is_array($fixed);
  800.             if ((!$isArray && $fixed) || (null !== $class && $isArray && \in_array($class, $fixed, true))) {
  801.                 $arrFields[] = $field;
  802.             }
  803.         }
  805.         return $arrFields;
  806.     }
  808.     /**
  809.      * Return list of variant fixed fields
  810.      * Fixed fields cannot be disabled in product type config
  811.      *
  812.      * @param string|null $class
  813.      *
  814.      * @return array
  815.      */
  816.     public static function getVariantFixedFields($class = null)
  817.     {
  818.         Controller::loadDataContainer('tl_iso_product');
  820.         $arrFields = array();
  821.         $arrDCA = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  823.         foreach ($arrDCA as $field => $config) {
  824.             $fixed   = $config['attributes']['variant_fixed'] ?? null;
  825.             $isArray = \is_array($fixed);
  827.             if ((!$isArray && $fixed) || (null !== $class && $isArray && \in_array($class, $fixed, true))) {
  828.                 $arrFields[] = $field;
  829.             }
  830.         }
  832.         return $arrFields;
  833.     }
  835.     /**
  836.      * Return list of excluded fields
  837.      * Excluded fields cannot be enabled in product type config
  838.      *
  839.      * @return array
  840.      */
  841.     public static function getExcludedFields()
  842.     {
  843.         static $arrFields;
  845.         if (null === $arrFields) {
  846.             Controller::loadDataContainer('tl_iso_product');
  848.             $arrFields = array();
  849.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  851.             foreach ($arrDCA as $field => $config) {
  852.                 if (($config['attributes']['excluded'] ?? false)) {
  853.                     $arrFields[] = $field;
  854.                 }
  855.             }
  856.         }
  858.         return $arrFields;
  859.     }
  861.     /**
  862.      * Return list of variant excluded fields
  863.      * Excluded fields cannot be disabled in product type config
  864.      *
  865.      * @return array
  866.      */
  867.     public static function getVariantExcludedFields()
  868.     {
  869.         static $arrFields;
  871.         if (null === $arrFields) {
  872.             Controller::loadDataContainer('tl_iso_product');
  874.             $arrFields = array();
  875.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  877.             foreach ($arrDCA as $field => $config) {
  878.                 if ($config['attributes']['variant_excluded'] ?? false) {
  879.                     $arrFields[] = $field;
  880.                 }
  881.             }
  882.         }
  884.         return $arrFields;
  885.     }
  887.     /**
  888.      * Return list of singular fields
  889.      * Singular fields must not be enabled in product AND variant configuration.
  890.      *
  891.      * @return array
  892.      */
  893.     public static function getSingularFields()
  894.     {
  895.         static $arrFields;
  897.         if (null === $arrFields) {
  898.             Controller::loadDataContainer('tl_iso_product');
  900.             $arrFields = array();
  901.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  903.             foreach ($arrDCA as $field => $config) {
  904.                 if ($config['attributes']['singular'] ?? false) {
  905.                     $arrFields[] = $field;
  906.                 }
  907.             }
  908.         }
  910.         return $arrFields;
  911.     }
  913.     /**
  914.      * Return list of fields that must be inherited by variants
  915.      *
  916.      * @return array
  917.      */
  918.     public static function getInheritFields()
  919.     {
  920.         static $arrFields;
  922.         if (null === $arrFields) {
  923.             Controller::loadDataContainer('tl_iso_product');
  925.             $arrFields = array();
  926.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  928.             foreach ($arrDCA as $field => $config) {
  929.                 if ($config['attributes']['inherit'] ?? false) {
  930.                     $arrFields[] = $field;
  931.                 }
  932.             }
  933.         }
  935.         return $arrFields;
  936.     }
  938.     /**
  939.      * Find all valid attributes
  940.      *
  941.      * @param array $arrOptions An optional options array
  942.      *
  943.      * @return \Isotope\Model\Attribute[]|null The model collection or null if the result is empty
  944.      */
  945.     public static function findValid(array $arrOptions = array())
  946.     {
  947.         $t = static::getTable();
  949.         // Allow to set custom option conditions
  950.         if (!isset($arrOptions['column'])) {
  951.             $arrOptions['column'] = [];
  952.         } elseif (!\is_array($arrOptions['column'])) {
  953.             $arrOptions['column'] = [$t.'.'.$arrOptions['column'].'=?'];
  954.         }
  956.         $arrOptions['column'][] = "$t.type!=''";
  957.         $arrOptions['column'][] = "$t.field_name!=''";
  959.         return static::findAll($arrOptions);
  960.     }
  962.     /**
  963.      * Get an attribute by database field name
  964.      *
  965.      * @param string $strField
  966.      * @param array  $arrOptions
  967.      *
  968.      * @return Model|null
  969.      */
  970.     public static function findByFieldName($strField, array $arrOptions = [])
  971.     {
  972.         if (!isset(static::$arrFieldNameMap[$strField])) {
  973.             $objAttribute = static::findOneBy('field_name', $strField, $arrOptions);
  975.             if (null === $objAttribute) {
  976.                 static::$arrFieldNameMap[$strField] = false;
  977.             } else {
  978.                 static::$arrFieldNameMap[$strField] = $objAttribute->id;
  979.             }
  981.             return $objAttribute;
  983.         }
  985.         if (static::$arrFieldNameMap[$strField] === false) {
  986.             return null;
  987.         }
  989.         return static::findByPk(static::$arrFieldNameMap[$strField], $arrOptions);
  990.     }
  991. }