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

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\Controller;
  15. use Contao\Database;
  16. use Contao\FilesModel;
  17. use Contao\Model;
  18. use Contao\StringUtil;
  19. use Haste\Util\Format;
  20. use Isotope\Interfaces\IsotopeAttribute;
  21. use Isotope\Interfaces\IsotopeAttributeWithOptions;
  22. use Isotope\Interfaces\IsotopeProduct;
  23. use Isotope\Isotope;
  24. use Isotope\Translation;
  27. /**
  28.  * Attribute represents a product attribute in Isotope eCommerce
  29.  *
  30.  * @property int           $id
  31.  * @property int           $tstamp
  32.  * @property string        $name
  33.  * @property string        $field_name
  34.  * @property string        $type
  35.  * @property string        $legend
  36.  * @property string        $description
  37.  * @property string        $optionsSource
  38.  * @property string|array  $options
  39.  * @property string        $foreignKey
  40.  * @property bool          $includeBlankOption
  41.  * @property string        $blankOptionLabel
  42.  * @property bool          $variant_option
  43.  * @property bool          $customer_defined
  44.  * @property bool          $be_search
  45.  * @property bool          $be_filter
  46.  * @property bool          $mandatory
  47.  * @property bool          $fe_filter
  48.  * @property bool          $fe_search
  49.  * @property bool          $fe_sorting
  50.  * @property bool          $multiple
  51.  * @property int           $size
  52.  * @property string        $extensions
  53.  * @property string        $rte
  54.  * @property bool          $multilingual
  55.  * @property bool          $rgxp
  56.  * @property bool          $placeholder
  57.  * @property int           $minlength
  58.  * @property int           $maxlength
  59.  * @property string        $conditionField
  60.  * @property string        $fieldType
  61.  * @property bool          $files
  62.  * @property bool          $filesOnly
  63.  * @property string        $sortBy
  64.  * @property string        $path
  65.  * @property bool          $storeFile
  66.  * @property string        $uploadFolder
  67.  * @property bool          $useHomeDir
  68.  * @property bool          $doNotOverwrite
  69.  * @property bool          $checkoutRelocate
  70.  * @property string        $checkoutTargetFolder
  71.  * @property string        $checkoutTargetFile
  72.  * @property bool          $datepicker
  73.  */
  74. abstract class Attribute extends TypeAgent implements IsotopeAttribute
  75. {
  77.     /**
  78.      * Table name
  79.      * @var string
  80.      */
  81.     protected static $strTable = 'tl_iso_attribute';
  83.     /**
  84.      * Interface to validate attribute
  85.      * @var string
  86.      */
  87.     protected static $strInterface = '\Isotope\Interfaces\IsotopeAttribute';
  89.     /**
  90.      * List of types (classes) for this model
  91.      * @var array
  92.      */
  93.     protected static $arrModelTypes = array();
  95.     /**
  96.      * Holds a map for field name to ID
  97.      * @var array
  98.      */
  99.     protected static $arrFieldNameMap = array();
  101.     /**
  102.      * Options for variants cache
  103.      * @var array
  104.      */
  105.     private $arrOptionsForVariants = array();
  107.     /**
  108.      * Return true if attribute is a variant option
  109.      *
  110.      * @return bool
  111.      *
  112.      * @deprecated will only be available when IsotopeAttributeForVariants interface is implemented
  113.      */
  114.     public function isVariantOption()
  115.     {
  116.         return (bool) $this->variant_option;
  117.     }
  119.     /**
  120.      * @inheritdoc
  121.      */
  122.     public function getFieldName()
  123.     {
  124.         return $this->field_name;
  125.     }
  127.     /**
  128.      * @inheritdoc
  129.      */
  130.     public function isCustomerDefined()
  131.     {
  132.         /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  133.         if ($this->isVariantOption()) {
  134.             return false;
  135.         }
  137.         return (bool) $this->customer_defined;
  138.     }
  140.     /**
  141.      * @inheritdoc
  142.      */
  143.     public function getBackendWidget()
  144.     {
  145.         if (!isset($GLOBALS['BE_FFL'][$this->type])) {
  146.             throw new \LogicException('Backend widget for attribute type "' . $this->type . '" does not exist.');
  147.         }
  149.         return $GLOBALS['BE_FFL'][$this->type];
  150.     }
  152.     /**
  153.      * @inheritdoc
  154.      */
  155.     public function getFrontendWidget()
  156.     {
  157.         if (!isset($GLOBALS['TL_FFL'][$this->type])) {
  158.             throw new \LogicException('Frontend widget for attribute type "' . $this->type . '" does not exist.');
  159.         }
  161.         return $GLOBALS['TL_FFL'][$this->type];
  162.     }
  164.     /**
  165.      * @inheritdoc
  166.      */
  167.     public function loadFromDCA(array &$arrData, $strName)
  168.     {
  169.         $arrField = &$arrData['fields'][$strName];
  171.         $this->arrData = \is_array($arrField['attributes']) ? $arrField['attributes'] : array();
  173.         if (\is_array($arrField['eval'] ?? null)) {
  174.             $this->arrData = array_merge($arrField['eval'], $this->arrData);
  175.         }
  177.         $this->field_name  = $strName;
  178.         $this->type        = array_search(\get_called_class(), static::getModelTypes(), true);
  179.         $this->name        = \is_array($arrField['label'] ?? null) ? $arrField['label'][0] : ($arrField['label'] ?? $strName);
  180.         $this->description = \is_array($arrField['label'] ?? null) ? $arrField['label'][1] : '';
  181.         $this->be_filter   = ($arrField['filter'] ?? false) ? '1' : '';
  182.         $this->be_search   = ($arrField['search'] ?? false) ? '1' : '';
  183.         $this->foreignKey  = $arrField['foreignKey'] ?? null;
  184.         $this->optionsSource = '';
  185.     }
  187.     /**
  188.      * @inheritdoc
  189.      */
  190.     public function saveToDCA(array &$arrData)
  191.     {
  192.         // Keep field settings made through DCA code
  193.         $arrField = \is_array($arrData['fields'][$this->field_name] ?? null) ? $arrData['fields'][$this->field_name] : [];
  195.         $arrField['label']                          = Translation::get(array($this->name, $this->description));
  196.         $arrField['exclude']                        = true;
  197.         $arrField['inputType']                      = '';
  198.         $arrField['attributes']                     = $this->row();
  199.         $arrField['attributes']['variant_option']   = $this->isVariantOption(); /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  200.         $arrField['attributes']['customer_defined'] = $this->isCustomerDefined();
  201.         $arrField['eval']                           = \is_array($arrField['eval'] ?? null) ? array_merge($arrField['eval'], $arrField['attributes']) : $arrField['attributes'];
  203.         if ('' !== (string) $this->placeholder) {
  204.             $arrField['eval']['placeholder'] = Translation::get($this->placeholder);
  205.         }
  207.         if (!$this->isCustomerDefined()) {
  208.             $arrField['inputType'] = (string) array_search($this->getBackendWidget(), $GLOBALS['BE_FFL'], true);
  209.         }
  211.         // Support numeric paths (fileTree)
  212.         unset($arrField['eval']['path']);
  213.         if ($this->path != '' && ($objFile = FilesModel::findByPk($this->path)) !== null) {
  214.             $arrField['eval']['path'] = $objFile->path;
  215.         }
  217.         // Only enable RTE config in the TextArea attribute
  218.         unset($arrField['eval']['rte']);
  220.         if ($this->be_filter) {
  221.             $arrField['filter'] = true;
  222.         }
  224.         if ($this->be_search) {
  225.             $arrField['search'] = true;
  226.         }
  228.         // Variant selection is always mandatory
  229.         /* @todo in 3.0: $this instanceof IsotopeAttributeForVariants */
  230.         if ($this->isVariantOption()) {
  231.             $arrField['eval']['mandatory'] = true;
  232.         }
  234.         if ($this->blankOptionLabel != '') {
  235.             $arrField['eval']['blankOptionLabel'] = Translation::get($this->blankOptionLabel);
  236.         }
  238.         // Prepare options
  239.         if (IsotopeAttributeWithOptions::SOURCE_FOREIGNKEY === $this->optionsSource && !$this->isVariantOption()) {
  240.             $arrField['foreignKey'] = $this->parseForeignKey($this->foreignKey, $GLOBALS['TL_LANGUAGE']);
  241.             unset($arrField['options'], $arrField['reference']);
  243.         } else {
  244.             $arrOptions = null;
  246.             switch ($this->optionsSource) {
  247.                 case IsotopeAttributeWithOptions::SOURCE_ATTRIBUTE:
  248.                     $arrOptions = StringUtil::deserialize($this->options);
  249.                     break;
  251.                 case IsotopeAttributeWithOptions::SOURCE_FOREIGNKEY:
  252.                     $foreignKey = $this->parseForeignKey($this->foreignKey, $GLOBALS['TL_LANGUAGE']);
  253.                     $arrKey     = explode('.', $foreignKey, 2);
  255.                     if ('' !== (string) $arrKey[0] && '' !== $arrKey[1]) {
  256.                         $arrOptions = Database::getInstance()
  257.                             ->execute("SELECT id AS value, {$arrKey[1]} AS label FROM {$arrKey[0]} ORDER BY label")
  258.                             ->fetchAllAssoc()
  259.                         ;
  260.                     }
  261.                     break;
  263.                 case IsotopeAttributeWithOptions::SOURCE_TABLE:
  264.                     $arrOptions = [];
  265.                     if ($this instanceof IsotopeAttributeWithOptions && null !== ($options = AttributeOption::findByAttribute($this, ['order' => AttributeOption::getTable().'.label']))) {
  266.                         foreach ($options as $model) {
  267.                             $arrOptions[] = [
  268.                                 'value' => $model->getLanguageId(),
  269.                                 'label' => $model->label,
  270.                             ];
  271.                         }
  272.                     }
  273.                     break;
  275.                 case IsotopeAttributeWithOptions::SOURCE_PRODUCT:
  276.                     $arrOptions = [];
  277.                     if ($this instanceof IsotopeAttributeWithOptions && null !== ($options = AttributeOption::findByProducts($this, ['order' => AttributeOption::getTable().'.label']))) {
  278.                         foreach ($options as $model) {
  279.                             $arrOptions[] = [
  280.                                 'value' => $model->getLanguageId(),
  281.                                 'label' => $model->label,
  282.                             ];
  283.                         }
  284.                     }
  285.                     break;
  287.                 default:
  288.                     if ($this instanceof IsotopeAttributeWithOptions) {
  289.                         unset($arrField['options'], $arrField['reference']);
  290.                     }
  291.             }
  293.             if (!empty($arrOptions) && \is_array($arrOptions)) {
  294.                 $arrField['default'] = array();
  295.                 $arrField['options'] = array();
  296.                 $arrField['eval']['isAssociative'] = true;
  297.                 unset($arrField['reference']);
  298.                 $strGroup = '';
  300.                 foreach ($arrOptions as $option) {
  301.                     if ($option['group'] ?? false) {
  302.                         $strGroup = Translation::get($option['label']);
  303.                         continue;
  304.                     }
  306.                     if ($strGroup != '') {
  307.                         $arrField['options'][$strGroup][$option['value']] = Translation::get($option['label']);
  308.                     } else {
  309.                         $arrField['options'][$option['value']] = Translation::get($option['label']);
  310.                     }
  312.                     if ($option['default'] ?? false) {
  313.                         $arrField['default'][] = $option['value'];
  314.                     }
  315.                 }
  317.                 if (empty($arrField['default']) || $this->isCustomerDefined()) {
  318.                     unset($arrField['default']);
  319.                 } else if (!$arrField['eval']['multiple']) {
  320.                     $arrField['default'] = reset($arrField['default']);
  321.                 }
  322.             }
  323.         }
  325.         unset($arrField['eval']['foreignKey'], $arrField['eval']['options']);
  327.         // Add field to the current DCA table
  328.         $arrData['fields'][$this->field_name] = $arrField;
  329.     }
  331.     /**
  332.      * Get field options
  333.      * @return  array
  334.      * @deprecated  will only be available when IsotopeAttributeWithOptions interface is implemented
  335.      */
  336.     public function getOptions()
  337.     {
  338.         $arrOptions = StringUtil::deserialize($this->options);
  340.         if (!\is_array($arrOptions)) {
  341.             return array();
  342.         }
  344.         return $arrOptions;
  345.     }
  347.     /**
  348.      * Get available variant options for a product
  349.      *
  350.      * @param int[] $arrIds
  351.      * @param array $arrOptions
  352.      *
  353.      * @return array
  354.      * @deprecated will only be available when IsotopeAttributeForVariants interface is implemented
  355.      */
  356.     public function getOptionsForVariants(array $arrIds, array $arrOptions = array())
  357.     {
  358.         if (0 === \count($arrIds)) {
  359.             return [];
  360.         }
  362.         sort($arrIds);
  363.         ksort($arrOptions);
  364.         $strKey = md5(implode('-', $arrIds) . '_' . json_encode($arrOptions));
  366.         if (!isset($this->arrOptionsForVariants[$strKey])) {
  367.             $strWhere = '';
  369.             foreach ($arrOptions as $field => $value) {
  370.                 $strWhere .= " AND $field=?";
  371.             }
  373.             $this->arrOptionsForVariants[$strKey] = Database::getInstance()->prepare('
  374.                 SELECT DISTINCT ' . $this->field_name . ' FROM tl_iso_product WHERE id IN (' . implode(',', $arrIds) . ')
  375.                 ' . $strWhere
  376.             )->execute($arrOptions)->fetchEach($this->field_name);
  377.         }
  379.         return $this->arrOptionsForVariants[$strKey];
  380.     }
  382.     /**
  383.      * @inheritdoc
  384.      */
  385.     public function getValue(IsotopeProduct $product)
  386.     {
  387.         return $product->{$this->field_name};
  388.     }
  390.     /**
  391.      * @inheritdoc
  392.      */
  393.     public function getLabel()
  394.     {
  395.         return Format::dcaLabel('tl_iso_product', $this->field_name);
  396.     }
  398.     /**
  399.      * Generate HTML markup of product data for this attribute
  400.      *
  401.      * @param IsotopeProduct $objProduct
  402.      * @param array          $arrOptions
  403.      *
  404.      * @return mixed
  405.      */
  406.     public function generate(IsotopeProduct $objProduct, array $arrOptions = array())
  407.     {
  408.         $varValue = $this->getValue($objProduct);
  409.         $arrOptions['product'] = $objProduct;
  411.         if (!\is_array($varValue)) {
  412.             return $this->generateValue($varValue, $arrOptions);
  413.         }
  415.         // Generate a HTML table for associative arrays
  416.         if (!array_is_assoc($varValue) && \is_array($varValue[0])) {
  417.             return $arrOptions['noHtml'] ? $varValue : $this->generateTable($varValue, $objProduct);
  418.         }
  420.         if ($arrOptions['noHtml']) {
  421.             $result = array();
  423.             foreach ($varValue as $v1) {
  424.                 $result[$v1] = $this->generateValue($v1, $arrOptions);
  425.             }
  427.             return $result;
  428.         }
  430.         // Generate ul/li listing for simple arrays
  431.         foreach ($varValue as &$v2) {
  432.             $v2 = $this->generateValue($v2, $arrOptions);
  433.         }
  435.         return $this->generateList($varValue);
  436.     }
  438.     /**
  439.      * @param mixed $value
  440.      * @param array $options
  441.      *
  442.      * @return string
  443.      */
  444.     public function generateValue($value, array $options = [])
  445.     {
  446.         return Format::dcaValue('tl_iso_product', $this->field_name, $value);
  447.     }
  449.     /**
  450.      * Returns the foreign key for a certain language with a fallback option
  451.      *
  452.      * @param string $strSettings
  453.      * @param bool   $strLanguage
  454.      *
  455.      * @return mixed
  456.      */
  457.     protected function parseForeignKey($strSettings, $strLanguage = false)
  458.     {
  459.         $strFallback = null;
  460.         $arrLines    = StringUtil::trimsplit('@\r\n|\n|\r@', $strSettings);
  462.         // Return false if there are no lines
  463.         if ($strSettings == '' || !\is_array($arrLines) || empty($arrLines)) {
  464.             return null;
  465.         }
  467.         // Loop over the lines
  468.         foreach ($arrLines as $strLine) {
  469.             // Ignore empty lines and comments
  470.             if ($strLine == '' || strpos($strLine, '#') === 0) {
  471.                 continue;
  472.             }
  474.             // Check for a language1
  475.             if (preg_match('/^([a-z]{2}(-[A-Z]{2})?)=(.+)$/', $strLine, $matches)) {
  476.                 $foreignKey = $matches[3];
  478.                 if ($matches[1] === $strLanguage) {
  479.                     return $foreignKey;
  480.                 }
  482.                 if (null === $strFallback) {
  483.                     $strFallback = $foreignKey;
  484.                 }
  485.             } elseif (null === $strFallback) {
  486.                 // The row without language is the fallback
  487.                 $strFallback = $strLine;
  488.             }
  489.         }
  491.         return $strFallback;
  492.     }
  494.     /**
  495.      * Generate HTML table for associative array values
  496.      *
  497.      * @param array          $arrValues
  498.      * @param IsotopeProduct $objProduct
  499.      *
  500.      * @return string
  501.      */
  502.     protected function generateTable(array $arrValues, IsotopeProduct $objProduct)
  503.     {
  504.         $arrFormat = $GLOBALS['TL_DCA']['tl_iso_product']['fields'][$this->field_name]['tableformat'];
  506.         $last = \count($arrValues[0]) - 1;
  508.         $strBuffer = '
  509. <table class="' . $this->field_name . '">
  510.   <thead>
  511.     <tr>';
  513.         foreach (array_keys($arrValues[0]) as $i => $name) {
  514.             if ($arrFormat[$name]['doNotShow']) {
  515.                 continue;
  516.             }
  518.             $label = $arrFormat[$name]['label'] ?: $name;
  520.             $strBuffer .= '
  521.       <th class="head_' . $i . ($i == 0 ? ' head_first' : '') . ($i == $last ? ' head_last' : '') . (!is_numeric($name) ? ' ' . StringUtil::standardize($name) : '') . '">' . $label . '</th>';
  522.         }
  524.         $strBuffer .= '
  525.     </tr>
  526.   </thead>
  527.   <tbody>';
  529.         foreach ($arrValues as $r => $row) {
  530.             $strBuffer .= '
  531.     <tr class="row_' . $r . ($r == 0 ? ' row_first' : '') . ($r == $last ? ' row_last' : '') . ' ' . ($r % 2 ? 'odd' : 'even') . '">';
  533.             $c = -1;
  535.             foreach ($row as $name => $value) {
  536.                 if ($arrFormat[$name]['doNotShow']) {
  537.                     continue;
  538.                 }
  540.                 if ('price' === $arrFormat[$name]['rgxp']) {
  541.                     $intTax = (int) $row['tax_class'];
  543.                     $value = Isotope::formatPriceWithCurrency(Isotope::calculatePrice($value, $objProduct, $this->field_name, $intTax));
  544.                 } else {
  545.                     $value = $arrFormat[$name]['format'] ? sprintf($arrFormat[$name]['format'], $value) : $value;
  546.                 }
  548.                 $strBuffer .= '
  549.       <td class="col_' . ++$c . ($c == 0 ? ' col_first' : '') . ($c == $last ? ' col_last' : '') . ' ' . StringUtil::standardize($name) . '">' . $value . '</td>';
  550.             }
  552.             $strBuffer .= '
  553.     </tr>';
  554.         }
  556.         $strBuffer .= '
  557.   </tbody>
  558. </table>';
  560.         return $strBuffer;
  561.     }
  563.     /**
  564.      * Generate HTML list for array values
  565.      *
  566.      * @param array $arrValues
  567.      *
  568.      * @return string
  569.      */
  570.     protected function generateList(array $arrValues)
  571.     {
  572.         $strBuffer = "\n<ul>";
  574.         $current = 0;
  575.         $last    = \count($arrValues) - 1;
  576.         foreach ($arrValues as $value) {
  577.             $class = trim(($current == 0 ? 'first' : '') . ($current == $last ? ' last' : ''));
  579.             $strBuffer .= "\n<li" . ($class != '' ? ' class="' . $class . '"' : '') . '>' . $value . '</li>';
  581.             ++$current;
  582.         }
  584.         $strBuffer .= "\n</ul>";
  586.         return $strBuffer;
  587.     }
  589.     /**
  590.      * Get list of system columns
  591.      *
  592.      * @return array
  593.      */
  594.     public static function getSystemColumnsFields()
  595.     {
  596.         static $arrFields;
  598.         if (null === $arrFields) {
  599.             Controller::loadDataContainer('tl_iso_product');
  601.             $arrFields = array();
  602.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  604.             foreach ($arrDCA as $field => $config) {
  605.                 if ($config['attributes']['systemColumn']) {
  606.                     $arrFields[] = $field;
  607.                 }
  608.             }
  609.         }
  611.         return $arrFields;
  612.     }
  614.     /**
  615.      * Return list of variant option fields
  616.      *
  617.      * @return array
  618.      */
  619.     public static function getVariantOptionFields()
  620.     {
  621.         static $arrFields;
  623.         if (null === $arrFields) {
  624.             Controller::loadDataContainer('tl_iso_product');
  626.             $arrFields = array();
  627.             $arrAttributes = &$GLOBALS['TL_DCA']['tl_iso_product']['attributes'];
  629.             /** @var Attribute $objAttribute */
  630.             foreach ($arrAttributes as $field => $objAttribute) {
  631.                 /* @todo in 3.0: $objAttribute instanceof IsotopeAttributeForVariants */
  632.                 if ($objAttribute->isVariantOption()) {
  633.                     $arrFields[] = $field;
  634.                 }
  635.             }
  636.         }
  638.         return $arrFields;
  639.     }
  641.     /**
  642.      * Return list of fields that are customer defined
  643.      *
  644.      * @return array
  645.      */
  646.     public static function getCustomerDefinedFields()
  647.     {
  648.         static $arrFields;
  650.         if (null === $arrFields) {
  651.             Controller::loadDataContainer('tl_iso_product');
  653.             $arrFields = array();
  654.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  656.             foreach ($arrDCA as $field => $config) {
  657.                 if ($config['attributes']['customer_defined'] ?? false) {
  658.                     $arrFields[] = $field;
  659.                 }
  660.             }
  661.         }
  663.         return $arrFields;
  664.     }
  666.     /**
  667.      * Return array of attributes that have price relevant information
  668.      *
  669.      * @return array
  670.      */
  671.     public static function getPricedFields()
  672.     {
  673.         static $arrFields;
  675.         if (null === $arrFields) {
  676.             $arrFields = Database::getInstance()->query("
  677.                 SELECT a.field_name
  678.                 FROM tl_iso_attribute a
  679.                 JOIN tl_iso_attribute_option o ON a.id=o.pid
  680.                 WHERE
  681.                   a.optionsSource='table'
  682.                   AND o.ptable='tl_iso_attribute'
  683.                   AND o.published='1'
  684.                   AND o.price!=''
  686.                 UNION
  688.                 SELECT a.field_name
  689.                 FROM tl_iso_attribute a
  690.                 JOIN tl_iso_attribute_option o ON a.field_name=o.field_name
  691.                 WHERE
  692.                   a.optionsSource='product'
  693.                   AND o.ptable='tl_iso_product'
  694.                   AND o.published='1'
  695.                   AND o.price!=''
  696.             ")->fetchEach('field_name');
  697.         }
  699.         return $arrFields;
  700.     }
  702.     /**
  703.      * Return list of fields that are multilingual
  704.      *
  705.      * @return array
  706.      */
  707.     public static function getMultilingualFields()
  708.     {
  709.         static $arrFields;
  711.         if (null === $arrFields) {
  712.             Controller::loadDataContainer('tl_iso_product');
  714.             $arrFields = array();
  715.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  717.             foreach ($arrDCA as $field => $config) {
  718.                 if ($config['attributes']['multilingual'] ?? null) {
  719.                     $arrFields[] = $field;
  720.                 }
  721.             }
  722.         }
  724.         return $arrFields;
  725.     }
  727.     /**
  728.      * Return list of fields that have fetch_fallback set
  729.      *
  730.      * @return array
  731.      */
  732.     public static function getFetchFallbackFields()
  733.     {
  734.         static $arrFields;
  736.         if (null === $arrFields) {
  737.             Controller::loadDataContainer('tl_iso_product');
  739.             $arrFields = array();
  740.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  742.             foreach ($arrDCA as $field => $config) {
  743.                 if ($config['attributes']['fetch_fallback'] ?? null) {
  744.                     $arrFields[] = $field;
  745.                 }
  746.             }
  747.         }
  749.         return $arrFields;
  750.     }
  752.     /**
  753.      * Return list of dynamic fields
  754.      * Dynamic fields cannot be filtered on database level (e.g. product price)
  755.      *
  756.      * @return array
  757.      */
  758.     public static function getDynamicAttributeFields()
  759.     {
  760.         static $arrFields;
  762.         if (null === $arrFields) {
  763.             Controller::loadDataContainer('tl_iso_product');
  765.             $arrFields = array();
  766.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  768.             foreach ($arrDCA as $field => $config) {
  769.                 if (($config['attributes']['dynamic'] ?? null)
  770.                     || (($config['eval']['multiple'] ?? null) && !($config['eval']['csv'] ?? null))
  771.                 ) {
  772.                     $arrFields[] = $field;
  773.                 }
  774.             }
  775.         }
  777.         return $arrFields;
  778.     }
  780.     /**
  781.      * Return list of fixed fields
  782.      * Fixed fields cannot be disabled in product type config
  783.      *
  784.      * @param string|null $class
  785.      *
  786.      * @return array
  787.      */
  788.     public static function getFixedFields($class = null)
  789.     {
  790.         Controller::loadDataContainer('tl_iso_product');
  792.         $arrFields = array();
  793.         $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  795.         foreach ($arrDCA as $field => $config) {
  796.             $fixed = ($config['attributes']['fixed'] ?? null);
  797.             $isArray = \is_array($fixed);
  799.             if ((!$isArray && $fixed) || (null !== $class && $isArray && \in_array($class, $fixed, true))) {
  800.                 $arrFields[] = $field;
  801.             }
  802.         }
  804.         return $arrFields;
  805.     }
  807.     /**
  808.      * Return list of variant fixed fields
  809.      * Fixed fields cannot be disabled in product type config
  810.      *
  811.      * @param string|null $class
  812.      *
  813.      * @return array
  814.      */
  815.     public static function getVariantFixedFields($class = null)
  816.     {
  817.         Controller::loadDataContainer('tl_iso_product');
  819.         $arrFields = array();
  820.         $arrDCA = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  822.         foreach ($arrDCA as $field => $config) {
  823.             $fixed   = $config['attributes']['variant_fixed'] ?? null;
  824.             $isArray = \is_array($fixed);
  826.             if ((!$isArray && $fixed) || (null !== $class && $isArray && \in_array($class, $fixed, true))) {
  827.                 $arrFields[] = $field;
  828.             }
  829.         }
  831.         return $arrFields;
  832.     }
  834.     /**
  835.      * Return list of excluded fields
  836.      * Excluded fields cannot be enabled in product type config
  837.      *
  838.      * @return array
  839.      */
  840.     public static function getExcludedFields()
  841.     {
  842.         static $arrFields;
  844.         if (null === $arrFields) {
  845.             Controller::loadDataContainer('tl_iso_product');
  847.             $arrFields = array();
  848.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  850.             foreach ($arrDCA as $field => $config) {
  851.                 if (($config['attributes']['excluded'] ?? false)) {
  852.                     $arrFields[] = $field;
  853.                 }
  854.             }
  855.         }
  857.         return $arrFields;
  858.     }
  860.     /**
  861.      * Return list of variant excluded fields
  862.      * Excluded fields cannot be disabled in product type config
  863.      *
  864.      * @return array
  865.      */
  866.     public static function getVariantExcludedFields()
  867.     {
  868.         static $arrFields;
  870.         if (null === $arrFields) {
  871.             Controller::loadDataContainer('tl_iso_product');
  873.             $arrFields = array();
  874.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  876.             foreach ($arrDCA as $field => $config) {
  877.                 if ($config['attributes']['variant_excluded'] ?? false) {
  878.                     $arrFields[] = $field;
  879.                 }
  880.             }
  881.         }
  883.         return $arrFields;
  884.     }
  886.     /**
  887.      * Return list of singular fields
  888.      * Singular fields must not be enabled in product AND variant configuration.
  889.      *
  890.      * @return array
  891.      */
  892.     public static function getSingularFields()
  893.     {
  894.         static $arrFields;
  896.         if (null === $arrFields) {
  897.             Controller::loadDataContainer('tl_iso_product');
  899.             $arrFields = array();
  900.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  902.             foreach ($arrDCA as $field => $config) {
  903.                 if ($config['attributes']['singular'] ?? false) {
  904.                     $arrFields[] = $field;
  905.                 }
  906.             }
  907.         }
  909.         return $arrFields;
  910.     }
  912.     /**
  913.      * Return list of fields that must be inherited by variants
  914.      *
  915.      * @return array
  916.      */
  917.     public static function getInheritFields()
  918.     {
  919.         static $arrFields;
  921.         if (null === $arrFields) {
  922.             Controller::loadDataContainer('tl_iso_product');
  924.             $arrFields = array();
  925.             $arrDCA    = &$GLOBALS['TL_DCA']['tl_iso_product']['fields'];
  927.             foreach ($arrDCA as $field => $config) {
  928.                 if ($config['attributes']['inherit'] ?? false) {
  929.                     $arrFields[] = $field;
  930.                 }
  931.             }
  932.         }
  934.         return $arrFields;
  935.     }
  937.     /**
  938.      * Find all valid attributes
  939.      *
  940.      * @param array $arrOptions An optional options array
  941.      *
  942.      * @return \Isotope\Model\Attribute[]|null The model collection or null if the result is empty
  943.      */
  944.     public static function findValid(array $arrOptions = array())
  945.     {
  946.         $t = static::getTable();
  948.         // Allow to set custom option conditions
  949.         if (!isset($arrOptions['column'])) {
  950.             $arrOptions['column'] = [];
  951.         } elseif (!\is_array($arrOptions['column'])) {
  952.             $arrOptions['column'] = [$t.'.'.$arrOptions['column'].'=?'];
  953.         }
  955.         $arrOptions['column'][] = "$t.type!=''";
  956.         $arrOptions['column'][] = "$t.field_name!=''";
  958.         return static::findAll($arrOptions);
  959.     }
  961.     /**
  962.      * Get an attribute by database field name
  963.      *
  964.      * @param string $strField
  965.      * @param array  $arrOptions
  966.      *
  967.      * @return Model|null
  968.      */
  969.     public static function findByFieldName($strField, array $arrOptions = [])
  970.     {
  971.         if (!isset(static::$arrFieldNameMap[$strField])) {
  972.             $objAttribute = static::findOneBy('field_name', $strField, $arrOptions);
  974.             if (null === $objAttribute) {
  975.                 static::$arrFieldNameMap[$strField] = false;
  976.             } else {
  977.                 static::$arrFieldNameMap[$strField] = $objAttribute->id;
  978.             }
  980.             return $objAttribute;
  982.         }
  984.         if (static::$arrFieldNameMap[$strField] === false) {
  985.             return null;
  986.         }
  988.         return static::findByPk(static::$arrFieldNameMap[$strField], $arrOptions);
  989.     }
  990. }