system/modules/pct_customelements/PCT/CustomElements/Core/Attribute.php line 136

Open in your IDE?
  1. <?php
  3. /**
  4.  * Contao Open Source CMS
  5.  * 
  6.  * Copyright (C) 2005-2013 Leo Feyer
  7.  * 
  8.  * @copyright    Tim Gatzky 2013, Premium Contao Webworks, Premium Contao Themes
  9.  * @author        Tim Gatzky <info@tim-gatzky.de>
  10.  * @package        pct_customelements
  11.  * @link        http://contao.org
  12.  */
  14. /**
  15.  * Namespace
  16.  */
  17. namespace PCT\CustomElements\Core;
  19. /**
  20.  * Imports
  21.  */
  23. use Contao\StringUtil;
  24. use PCT\CustomElements\Core\Vault as Vault;
  25. use PCT\CustomElements\Helper\ControllerHelper as ControllerHelper;
  26. use PCT\CustomElements\Core\FrontendTemplate as FrontendTemplate;
  27. use PCT\CustomElements\Core\Cache as Cache;
  29. /**
  30.  * Class file
  31.  * Attribute
  32.  */
  33. class Attribute extends \PCT\CustomElements\Core\Controller implements \PCT\CustomElements\Interfaces\Attribute
  34. {
  35.     /**
  36.      * Widget
  37.      * @var object
  38.      */
  39.     // !$objWidget
  40.     protected $objWidget;
  41.     
  42.     /**
  43.      * Origin object
  44.      * @var object
  45.      */
  46.     // !$objOrigin
  47.     protected $objOrigin = null;
  48.     
  49.     /**
  50.      * Child attributes array
  51.      * @var array
  52.      */
  53.     // !$arrChildAttributes
  54.     protected $arrChildAttributes = array();
  55.     
  56.     /**
  57.      * Template for a single field
  58.      * @var string
  59.      */
  60.     // !$strFieldTemplate
  61.     protected $strFieldTemplate = 'be_field_customelement';
  62.     
  63.     /**
  64.      * Value
  65.      * @var mixed
  66.      */
  67.     // !$varValue
  68.     protected $varValue = null;
  69.     
  70.     /**
  71.      * Modified array
  72.      * @var array
  73.      */
  74.     // !$arrModified
  75.     protected $arrModified = array();
  76.     
  77.     /**
  78.      * Options values array
  79.      * @var array
  80.      */
  81.     // !$arrOptionValues
  82.     protected $arrOptionValues = array();
  83.     
  84.     /**
  85.      * Translated labels array
  86.      * @var array
  87.      * 
  88.      */
  89.     // !$arrTranslatedLabel
  90.     protected $arrTranslations = array();
  92.     /**
  93.      * Flag that a custom template is used
  94.      * @protected boolean
  95.      */
  96.     protected $isCustomTemplate = false;
  98.     /**
  99.      * Uuid of the attribute
  100.      * @protected boolean
  101.      */
  102.     public $uuid = '';
  104.     /**
  105.      * Flag if an attribute is a copy
  106.      * @protected boolean
  107.      */
  108.     public $isCopy = false;
  110.     /**
  111.      * Flag if an attribute should be copied
  112.      * @protected boolean
  113.      */
  114.     public $createCopy = false;
  116.     /**
  117.      * Counter of copy
  118.      * @protected boolean
  119.      */
  120.     public $numCopy = 0;
  122.     /**
  123.      * Flag if an attribute is sortable
  124.      * @protected boolean
  125.      */
  126.     public $sortable = false;
  128.     
  129.     /**
  130.      * Create a new instance
  131.      * @param array
  132.      */
  133.     public function __construct($arrData=array())
  134.     {
  135.         $this->setData($arrData);
  136.         $this->Session = \Contao\System::getContainer()->get('session');
  137.         $this->isCopy = false;
  138.     }
  139.     
  140.     
  141.     /**
  142.      * Generate the attribute
  143.      * @return object Attribute
  144.      */
  145.     public function generate()
  146.     {
  147.         $arrData = $this->getData();
  148.         
  149.         if(empty( $arrData ))
  150.         {
  151.             return null;
  152.         }
  153.         
  154.         return \PCT\CustomElements\Core\AttributeFactory::findById( $this->get('id') );
  155.     }
  156.     
  157.     
  158. //! --- Interface ---    
  159.     
  160.     
  161.     /**
  162.      * @inheritdoc
  163.      */
  164.     public function getFieldDefinition()
  165.     {
  166.         return array();
  167.     }    
  168.     
  170. //! --- Vault ---    
  171.     /**
  172.      * Set value for this attribute
  173.      * @param mixed
  174.      */
  175.     public function setValue($varValue)
  176.     {
  177.         $this->set('varValue',$varValue);
  178.         
  179.         // mark this variable as modified
  180.         $this->setModified('varValue');
  181.     }
  182.     
  183.     
  184.     /**
  185.      * Return the value
  186.      * @return mixed
  187.      */
  188.     public function getValue()
  189.     {
  190.         $varValue = $this->get('varValue');
  191.         
  192.         // load value hook
  193.         $varValue = \PCT\CustomElements\Core\Hooks::callstatic('loadValueHook',array($varValue,$this));
  194.         
  195.         return $varValue;
  196.     }
  197.     
  198.     
  199.     /**
  200.      * Store an attribute value to the vault
  201.      * @param mixed        Value
  202.      * @param string    Name of the attribute (uuid)
  203.      * @param integer    Id of the (contao) element
  204.      * @param string    Source table e.g. tl_content
  205.      * @param array        Optional settings array
  206.      */
  207.     protected function saveValue($varValue,$strField,$intPid=0,$strTable='',$arrOptions=array())
  208.     {
  209.         // set the current value in object scope when it is not a child
  210.         if(!$this->isChild($strField))
  211.         {
  212.             $this->setValue($varValue);
  213.         }
  214.     }
  215.     
  216.     
  217.     /**
  218.      * Public shortcut to saveValue
  219.      * @see saveValue
  220.      */
  221.     public function save($varValue,$intPid=0,$strTable='',$arrOptions=array())
  222.     {
  223.         $strField = $this->uuid ? $this->uuid : $this->get('uuid');
  224.         $this->saveValue($varValue,$strField,$intPid,$strTable,$arrOptions);
  225.     }
  227.     
  228.     /**
  229.      * Load the attribute value from the vault
  230.      * @param string    Name of the attribute (uuid)
  231.      * @param integer    Id of the (contao) element
  232.      * @param string    Source table e.g. tl_content
  233.      * @param array        Optional settings array
  234.      * @return string
  235.      */
  236.     protected function loadValue($strField,$intPid=0,$strTable='',$arrOptions=array())
  237.     {
  238.         // return the value if set from outside
  239.         if($this->isModified('varValue') && !$this->isChild($strField))
  240.         {
  241.             $varValue = $this->getValue();
  242.         }
  243.         else
  244.         {
  245.             $objOrigin = $this->get('objOrigin');
  246.             if( $objOrigin === null )
  247.             {
  248.                 $objOrigin = Origin::getInstance();
  249.             }
  250.             
  251.             if($intPid < 1) {$intPid = $objOrigin::get('pid');}
  252.             if(strlen($strTable) < 1) {$strTable = $objOrigin::get('table');}
  253.             
  254.             $this->set('objOrigin',$objOrigin);
  255.             
  256.             if(empty($arrOptions))
  257.             {
  258.                 $arrOptions = $this->getData();
  259.             }
  260.             
  261.             $objCustomElement = $this->getCustomElement();
  263.             $arrOptions['saveDataAs'] = isset($arrOptions['saveDataAs']) ? $arrOptions['saveDataAs'] : $this->get('saveDataAs');
  264.             $arrOptions['attr_id'] = isset($arrOptions['attr_id']) ? $arrOptions['attr_id'] : $this->get('id');
  265.             $arrOptions['type'] = isset($arrOptions['type']) ? $arrOptions['type'] : $this->get('type');
  266.             $arrOptions['genericAttribute'] = $objCustomElement->getGenericAttribute();
  267.             
  268.             // fetch the value from the vault
  269.             $varValue = Vault::getAttributeValueByUuid($strField,$intPid,$strTable,$arrOptions);
  270.             
  271.             // set the current value in object scope when it is not a child
  272.             if(!$this->isChild($strField))
  273.             {
  274.                 $this->setValue($varValue);
  275.             }
  276.         }
  277.         
  278.         // load value hook
  279.         $varValue = \PCT\CustomElements\Core\Hooks::callstatic('loadValueHook',array($varValue,$this));
  280.         
  281.         return $varValue;
  282.     }
  283.     
  284.     
  285.     /**
  286.      * Public shortcut to saveValue
  287.      * @see saveValue
  288.      */
  289.     public function load($intPid=0,$strTable='',$arrOptions=array())
  290.     {
  291.         $strField = $this->uuid ? $this->uuid : $this->get('uuid');
  292.         return $this->loadValue($strField,$intPid,$strTable,$arrOptions);
  293.     }
  294.     
  295.     
  296.     /**
  297.      * Load an options value
  298.      * @param string    Name of the option key
  299.      * @param integer
  300.      * @param string
  301.      * @param array
  302.      * @return mixed
  303.      */
  304.     public function loadOptionValue($strOption,$intPid=0,$strTable='',$arrOptions=array())
  305.     {
  306.         if($this->isModified('arrOptionValues'))
  307.         {
  308.             return $this->arrOptionValues[$strOption] ?? null;
  309.         }
  310.         
  311.         $strField = $this->uuid ? $this->uuid : $this->get('uuid');
  312.         $strField .= '_'.$strOption;
  313.         return $this->loadValue($strField,$intPid,$strTable,$arrOptions);
  314.     }
  315.     
  316.     
  317.     /**
  318.      * Load all option values and return them as associated array
  319.      * @param string
  320.      * @param integer
  321.      * @param string
  322.      * @return array
  323.      */
  324.     public function loadOptionValues($strField,$intPid=0,$strTable='')
  325.     {
  326.         if($this->isModified('arrOptionValues'))
  327.         {
  328.             return $this->get('arrOptionValues');
  329.         }
  330.         
  331.         $objOrigin = $this->get('objOrigin');
  332.         if($intPid < 1 && isset($objOrigin)) {$intPid = $objOrigin::get('pid');}
  333.         if(strlen($strTable) < 1 && isset($objOrigin)) {$strTable = $objOrigin::get('table');}
  334.         
  335.         if($intPid < 1 && strlen($strTable) < 1)
  336.         {
  337.             return array();
  338.         }
  339.         
  340.         // get the values from the wizard
  341.         $arrWizard = Vault::getWizardData($intPid,$strTable);
  342.         $arrOptions = StringUtil::deserialize($this->get('options'));
  343.         
  344.         if(!is_array($arrOptions))
  345.         {
  346.             $arrOptions = array_filter(explode(',', $arrOptions));
  347.         }
  348.         
  349.         if(!empty($arrWizard['values']) && !empty($arrOptions) && is_array($arrOptions) && !in_array($this->get('type'), $GLOBALS['PCT_CUSTOMELEMENTS']['ignoreOptionFields']))
  350.         {
  351.             $arrOptionValues = array();
  352.             foreach($arrOptions as $option)
  353.             {
  354.                 if(isset($arrWizard['values'][$strField.'_'.$option]))
  355.                 {
  356.                     $arrOptionValues[] = $arrWizard['values'][$strField.'_'.$option];
  357.                 }
  358.             }
  359.             
  360.             $this->setOptionValues($arrOptionValues);
  361.         
  362.             return $arrOptionValues;
  363.         }
  365.         return array();
  366.     }
  367.     
  368.     
  369.     /**
  370.      * Allow to set the options value array from outside
  371.      * @param array
  372.      */
  373.     public function setOptionValues($arrValues)
  374.     {
  375.         $this->set('arrOptionValues',$arrValues);
  376.         
  377.         // flag this variable to be modified
  378.         $this->setModified('arrOptionValues');
  379.     }
  380.     
  381.     
  382.     /**
  383.      * (DEPRECATED)
  384.      * Load the attribute value from the vault
  385.      * @param string
  386.      * @param integer
  387.      * @param string
  388.      * @return mixed
  389.      */
  390.     public function findValueByField($strField,$strSaveDataAs='')
  391.     {
  392.         return $this->loadValue($strField,null,null,array('saveDataAs'=>$strSaveDataAs));
  393.     }
  395.     
  396.     /**
  397.      * Return the active record from the origin
  398.      * @param boolean    Flag to create a pseudo record
  399.      * @param string    The table to create the record from
  400.      * @return object
  401.      */
  402.     public function getActiveRecord($bolIsPseudo=false, $strTable='tl_content')
  403.     {
  404.         if($this->get('objActiveRecord'))
  405.         {
  406.             $objReturn = $this->get('objActiveRecord');
  407.             $objReturn = clone($objReturn);
  408.             if( $objReturn->id === null || (int)$this->get('objActiveRecord')->id > 0 )
  409.             {
  410.                 $objReturn->id = $this->get('objActiveRecord')->id;
  411.             }
  412.             return $objReturn;
  413.         }
  414.         
  415.         if($this->get('objOrigin') && !$bolIsPseudo)
  416.         {
  417.             $objReturn = $this->get('objOrigin')->get('activeRecord');
  418.             if( $objReturn->id === null )
  419.             {
  420.                 $objReturn->id = $this->get('objOrigin')->get('activeRecord')->id;
  421.             }
  422.         }
  423.         else if($bolIsPseudo)
  424.         {
  425.             $objReturn = \Contao\Database::getInstance()->prepare("SELECT * FROM ".$strTable." WHERE id=?")->limit(1)->execute(-1);
  426.             $this->set('objActiveRecord',$objReturn);
  427.         }
  428.         else
  429.         {
  430.             return null;
  431.         }
  432.         
  433.         // strip the active record from contao fields
  434.         if(!empty($objReturn) && is_array($GLOBALS['PCT_CUSTOMELEMENTS']['fieldnamesSharedWithContao']) && count($GLOBALS['PCT_CUSTOMELEMENTS']['fieldnamesSharedWithContao']) > 0)
  435.         {
  436.             foreach($GLOBALS['PCT_CUSTOMELEMENTS']['fieldnamesSharedWithContao'] as $f)
  437.             {
  438.                 if(isset($objReturn->{$f}))
  439.                 {
  440.                     $objReturn->{$f} = null;
  441.                 }
  442.             }
  443.         }
  444.         
  445.         if( $objReturn === null )
  446.         {
  447.             return null;
  448.         }
  449.         
  450.         return clone( $objReturn );
  451.     }
  452.     
  453.      
  454. //! --- DCA handling ---    
  457.     /**
  458.      * Generate the field and return html string
  459.      * @param array
  460.      * @param object
  461.      * @return string
  462.      */
  463.     public function generateWidget($objDC)
  464.     {
  465.         $varValue = '';
  466.         $strBuffer = '';
  467.         $objDC = clone($objDC);
  468.         
  469.         // get attribute session
  470.         if( !isset($this->Session) || $this->Session === null )
  471.         {
  472.             $this->Session = \Contao\System::getContainer()->get('session');
  473.         }
  475.         $arrSession = $this->Session->get('pct_customelement_attribute');
  476.         if( \is_array($arrSession) === false )
  477.         {
  478.             $arrSession = array();
  479.         }
  480.         // get attribute registry session
  481.         $arrCeSession = $this->Session->get('pct_customelements');
  482.         if( \is_array($arrCeSession) === false )
  483.         {
  484.             $arrCeSession = array();
  485.         }
  486.         $arrRegistry = $arrCeSession['registry'][$objDC->table][$objDC->id] ?? array();
  487.         if(!is_array($arrRegistry))
  488.         {
  489.             $arrRegistry = array();
  490.         }
  491.         
  492.         // set name / uuid
  493.         $this->set('uuid',$objDC->field);
  494.         
  495.         // get the field definition for this attribute
  496.         $arrFieldDef = $this->getFieldDefinition();
  497.         $this->set('dataContainer', $objDC);
  498.         #$arrFieldDef['dataContainer'] = $objDC;
  500.         // translate the labels and descriptions
  501.         $arrTranslatedLabel = $this->getTranslatedLabel();
  502.         if(is_array($arrTranslatedLabel) && !empty($arrTranslatedLabel)) 
  503.         {
  504.             $arrFieldDef['label'] = $arrTranslatedLabel;
  505.         }
  506.         
  507.         // TL_DCA, dcaconfig.php
  508.         $strAlias = $this->get('alias');
  509.         #if($this->createCopy || $this->isCopy)
  510.         #{
  511.         #    $strAlias = $this->get('alias').'#'.$this->numCopy;
  512.         #}
  513.         if( isset($GLOBALS['CE_DCA'][$objDC->table]['fields'][$strAlias]) || isset($GLOBALS['CE_DCA'][$objDC->table]['fields'][$objDC->field]) )
  514.         {
  515.             $f = $strAlias;
  516.             if( isset($GLOBALS['CE_DCA'][$objDC->table]['fields'][$objDC->field]) )
  517.             {
  518.                 $f = $objDC->field;
  519.             }
  520.             $label = $arrFieldDef['label'];
  521.             $arrFieldDef = \array_replace_recursive($arrFieldDef,$GLOBALS['CE_DCA'][$objDC->table]['fields'][$f]);
  522.             if( empty($arrFieldDef['label']) )
  523.             {
  524.                 $arrFieldDef['label'] = $label;
  525.             }
  526.         }
  527.         
  528.         // mark attribute as sortable
  529.         $this->sortable = false;
  530.         if( isset($arrFieldDef['sortable']) )
  531.         {
  532.             $this->sortable = $arrFieldDef['sortable'];
  533.         }
  534.         
  535.         // put the field in the data container
  536.         $GLOBALS['TL_DCA'][$objDC->table]['fields'][$objDC->field] = $arrFieldDef;
  537.         
  538.         // catch the submitted value
  539.         if(\Contao\Input::post('FORM_SUBMIT') == $objDC->table && isset($_POST[$objDC->field]) && !$this->get('doNotSave'))
  540.         {
  541.             $varValue = \Contao\Input::post($objDC->field);
  542.             if( isset($arrFieldDef['eval']['rte']) && $arrFieldDef['eval']['rte'] || isset($arrFieldDef['eval']['allowHtml']) && $arrFieldDef['eval']['allowHtml'])
  543.             {
  544.                 $varValue = \Contao\Input::postRaw($objDC->field);
  545.             }
  546.             
  547.             if($this->sortable && \Contao\Input::post('orderSRC_'.$objDC->field))
  548.             {
  549.                 $varValue = \Contao\Input::post('orderSRC_'.$objDC->field);
  550.             }
  551.             
  552.             // remove the temp. value when user submitted the widget
  553.             if(isset($arrSession[$objDC->field]))
  554.             {
  555.                 unset($arrSession[$objDC->field]);
  556.                 $this->Session->set('pct_customelement_attribute',$arrSession);
  557.             }
  558.         }
  559.         else
  560.         {
  561.             $varValue = $this->load($objDC->id,$objDC->table);
  562.             
  563.             // store field value from parent in session when created via ajax
  564.             if($this->isCopy && (\Contao\Input::get('ajax') || \Contao\Input::post('ajax')))
  565.             {
  566.                   $this->set('uuid',$objDC->pattr_uuid);
  567.                 $varValue = $this->load($objDC->id,$objDC->table);
  568.                 $session = array($objDC->field => array('value'=>$varValue));
  569.                 $this->Session->set('pct_customelement_attribute',$session);
  570.             }
  571.         }
  572.         
  573.         // load the temp. value from the session if it exists
  574.         if( isset($arrSession[$objDC->field]) && $arrSession[$objDC->field])
  575.         {
  576.             $varValue = $arrSession[$objDC->field]['value'];
  577.         }
  578.         
  579.         // load default value
  580.         if(!isset($varValue) && $this->get('defaultValue') || $varValue == false)
  581.         {
  582.             // double check if the field really has no entry in the vault yet
  583.             if(!Vault::fieldExists($objDC->field,$objDC->id,$objDC->table))
  584.             {
  585.                 $varValue = $this->get('defaultValue');
  586.             }
  587.         }
  588.         
  589.         // trigger load callback
  590.         if( isset($arrFieldDef['load_callback']) && is_array($arrFieldDef['load_callback']))
  591.         {
  592.             $objDC->objAttribute = $this;
  593.             foreach($arrFieldDef['load_callback'] as $callback)
  594.             {
  595.                 if (is_array($callback))
  596.                 {
  597.                    $varValue = ControllerHelper::importStatic($callback[0])->{$callback[1]}($varValue,$objDC,$this);    
  598.                 }
  599.                 else if(is_callable($callback))
  600.                 {
  601.                    $varValue = $callback($varValue,$objDC,$this);
  602.                 }
  603.             }
  604.         }
  605.         
  606.         // Store the field definitions in the session for further use
  607.         $arrRegistry[$objDC->field] = array
  608.         (
  609.             'id'        => $this->get('id'),
  610.             'name'        => $objDC->field,
  611.             'fieldDef'    => $arrFieldDef,
  612.         );
  613.         $arrCeSession['registry'][$objDC->table][$objDC->id] = $arrRegistry; 
  614.         $this->Session->set('pct_customelements',$arrCeSession);
  615.         //--
  616.         
  617.         $objActiveRecord = $objDC->activeRecord;
  618.         $strModel = \Contao\Model::getClassFromTable($objDC->table) ?? '';
  619.         if($objActiveRecord === null && class_exists($strModel))
  620.         {
  621.             $objActiveRecord = $strModel::findByPk($objDC->id);
  622.         }
  623.         else if($objActiveRecord === null && !class_exists($strModel))
  624.         {
  625.             $objActiveRecord = \Contao\Database::getInstance()->prepare("SELECT * FROM ".$objDC->table." WHERE id=?")->limit(1)->execute($objDC->id);
  626.         }
  627.         
  628.         // create the widget
  629.         $strClass = $GLOBALS['BE_FFL'][$arrFieldDef['inputType']];
  630.         if(strlen($strClass) < 1 || !class_exists($strClass))
  631.         {
  632.             return '';
  633.         }
  634.         
  635.         $arrFieldDef['activeRecord'] = $objActiveRecord;
  636.         
  637.         // replace null values with empty arrays because contaos validator might run in foreach loops (e.g. Contao\InputUnit)
  638.         if($varValue === null)
  639.         {
  640.             $varValue = '';
  641.         }
  643.         if( !isset($arrFieldDef['label'][0]) )
  644.         {
  645.             $arrFieldDef['label'][0] = $this->get('title');
  646.         }
  647.         if( !isset($arrFieldDef['label'][1]) )
  648.         {
  649.             $arrFieldDef['label'][1] = $this->get('description');
  650.         }
  651.         
  652.         $arrAttributes = $strClass::getAttributesFromDca($arrFieldDef,$objDC->field,$varValue,$objDC->field,$objDC->table,$objDC);
  653.         
  654.         $objWidget = new $strClass($arrAttributes);
  655.         $objWidget->__set('activeRecord',$objActiveRecord);
  657.         // handle binary data
  658.         #if(!empty($varValue) && !is_array($varValue))
  659.         #{
  660.         #    if($this->saveDataAs == 'binary' || \Contao\Validator::isBinaryUuid($varValue))
  661.         #    {
  662.         #        $objWidget->__set('value',\Contao\StringUtil::binToUuid($varValue));
  663.         #    }
  664.         #}
  665.         
  666.         // trigger save callbacks on submit
  667.         if(\Contao\Input::post('FORM_SUBMIT') == $objDC->table && !$this->get('doNotSave'))
  668.         {
  669.             $submitted_value = $varValue;
  670.             // store sorted values
  671.             if($this->sortable && \Contao\Input::post('orderSRC_'.$objDC->field))
  672.             {
  673.                 $varValue = \Contao\Input::post('orderSRC_'.$objDC->field);
  674.             }
  675.             // trigger save callback
  676.             if( isset($arrFieldDef['save_callback']) && is_array($arrFieldDef['save_callback']))
  677.             {
  678.                 $objDC->objAttribute = $this;
  679.                 foreach($arrFieldDef['save_callback'] as $callback)
  680.                 {
  681.                     if (is_array($callback))
  682.                     {
  683.                        $varValue = ControllerHelper::importStatic($callback[0])->{$callback[1]}($varValue,$objDC,$this);    
  684.                     }
  685.                     else if(is_callable($callback))
  686.                     {
  687.                        $varValue = $callback($varValue,$objDC,$this);
  688.                     }
  689.                 }
  690.             }
  691.             
  692.             // do not save the value if return value is an object (exception) 
  693.             if(is_object($varValue))
  694.             {
  695.                 $error = $varValue->getMessage();
  696.                 
  697.                 $objWidget->addError($error);
  698.                 
  699.                 // reset to the input value and store error in session for reload
  700.                 $varValue = $submitted_value;
  701.             }
  702.         }
  703.         
  704.         // trigger load callback
  705.         if(!\Contao\Input::post('FORM_SUBMIT'))
  706.         {
  707.             if( isset($arrFieldDef['load_callback']) && is_array($arrFieldDef['load_callback']))
  708.             {
  709.                 $objDC->objAttribute = $this;
  710.                 foreach($arrFieldDef['load_callback'] as $callback)
  711.                 {
  712.                     if (is_array($callback))
  713.                     {
  714.                        $varValue = ControllerHelper::importStatic($callback[0])->{$callback[1]}($varValue,$objDC,$this);    
  715.                     }
  716.                     else if(is_callable($callback))
  717.                     {
  718.                        $varValue = $callback($varValue,$objDC,$this);
  719.                     }
  720.                 }
  721.             }
  722.         }
  723.         
  724.         if( isset($arrSession[$objDC->field]['error']) &&  $arrSession[$objDC->field]['error'])
  725.         {
  726.             $objWidget->addError($arrSession[$objDC->field]['error']);
  727.         }
  728.         
  729.         // set value as POST value for the validator
  730.         if( !\Contao\Environment::get('isAjaxRequest') )
  731.         {
  732.             $v = $objWidget->__get('value');
  733.             if(!is_array($v) && $v !== null)
  734.             {
  735.                 if(\Contao\Validator::isBinaryUuid($v))
  736.                 {
  737.                     $v = \Contao\StringUtil::binToUuid($v);
  738.                 }
  739.                 $objWidget->__set('value',$v);
  740.             }
  741.             
  742.             \Contao\Input::setPost($objDC->field,$objWidget->__get('value'));
  743.             
  744.             #if(\Contao\Input::post('REQUEST_TOKEN') == '')
  745.             #{
  746.             #    \Contao\Input::setPost('REQUEST_TOKEN',REQUEST_TOKEN);
  747.             #}
  748.         }
  749.         
  750.         // decode entities
  751.         if( isset($arrFieldDef['eval']['decodeEntities']) && $arrFieldDef['eval']['decodeEntities'] )
  752.         {
  753.             $objWidget->__set('value', \Contao\StringUtil::decodeEntities($objWidget->__get('value')) );
  754.         }
  755.         
  756.         // check if the attribute itself calls its generateWidget function
  757.         if(method_exists($this,'parseWidgetCallback'))
  758.         {
  759.             if( !isset($arrFieldDef['dataContainer']) || !$arrFieldDef['dataContainer'])
  760.             {
  761.                 $arrFieldDef['dataContainer'] = $objDC;
  762.             }
  763.             $strBuffer = \call_user_func_array(array($this, 'parseWidgetCallback'), array($objWidget,$objDC->field,$arrFieldDef,$objDC,$objWidget->__get('value')) );
  764.         }
  765.         else
  766.         {
  767.             // validate the input
  768.             if( \Contao\Input::post($objDC->field) !== null )
  769.             {
  770.                 $objWidget->validate();
  771.             }
  772.             
  773.             if($objWidget->hasErrors())
  774.             {
  775.                 $objWidget->class = 'error';
  776.             }
  777.             
  778.             $strBuffer = $objWidget->parse();
  779.         }
  780.         
  781.         
  782.         // if the widget has an error store the value in the session, do not save in the vault
  783.         if($objWidget->hasErrors())
  784.         {
  785.             $objDC->noReload = true;
  786.             $session = array($objDC->field => array('value'=>$varValue,'error'=>$error));
  787.             $this->Session->set('pct_customelement_attribute',$session);
  788.         }
  789.         else
  790.         {
  791.             if($varValue != '' || (isset($arrFieldDef['eval']['doNotSaveEmpty']) && !$arrFieldDef['eval']['doNotSaveEmpty']) || !$this->get('doNotSave'))
  792.             {
  793.                 if($varValue === '')
  794.                 {
  795.                     $varValue = \Contao\Widget::getEmptyValueByFieldType($arrFieldDef['sql']);
  796.                 }
  797.             }
  798.             
  799.             // save value
  800.             $this->save($varValue,$objDC->id,$objDC->table);    
  801.         }
  802.         
  803.         // do not render the field at all when the output is none
  804.         if(strlen($strBuffer) < 1)
  805.         {
  806.             return '';
  807.         }
  808.         
  809.         // make the field sortable
  810.         if($this->sortable && strlen(strpos($strBuffer, 'orderSRC_'.$objDC->field)) < 1)
  811.         {
  812.             $doc = new \DOMDocument();
  813.             @$doc->loadHTML(preg_replace("/&(?!(?:apos|quot|[gl]t|amp);|#)/", "&amp;",$strBuffer));
  814.             $elem = $doc->getElementById('sort_'.$objDC->field);
  815.             
  816.             if($elem)
  817.             {
  818.                 $class = $doc->createAttribute('class');
  819.                 $class->value = 'sortable' . ($arrFieldDef['eval']['isGallery'] ? ' sgallery':'');
  820.                 $elem->appendChild($class);
  821.                 
  822.                 $str = '<p class="sort_hint">' . $GLOBALS['TL_LANG']['MSC']['dragItemsHint'] . '</p>';
  823.                 $str .= $elem->C14N();
  824.                 $str .= '<input type="hidden" id="ctrl_orderSRC_'.$objDC->field.'" name="orderSRC_'.$objDC->field.'" value="'.$varValue.'">';
  825.                 $str .= '<script>Backend.makeMultiSrcSortable("sort_'.$objDC->field.'", "ctrl_orderSRC_'.$objDC->field.'","ctrl_orderSRC_'.$objDC->field.'")</script>';
  826.                 // replace sort container
  827.                 $preg = preg_match('/<ul(.*?)\/ul>/', $strBuffer,$result); 
  828.                 if($preg)
  829.                 {
  830.                     $strBuffer = str_replace($result[0], $str, $strBuffer);
  831.                 }
  832.             }
  833.             // fallback if DOMDocument fails
  834.             else
  835.             {
  836.                 $preg = preg_match('/<ul id="sort_'.$objDC->field.'"(.*?)\/ul>/', $strBuffer,$result); 
  837.                 if($preg)
  838.                 {
  839.                     $tmp = $result[0];
  840.                     // inject the class
  841.                     $elem = preg_replace('/class="/', 'class="sortable ', $tmp, 1);
  842.                     
  843.                     $str = '<p class="sort_hint">' . $GLOBALS['TL_LANG']['MSC']['dragItemsHint'] . '</p>';
  844.                     $str .= $elem;
  845.                     $str .= '<input type="hidden" id="ctrl_orderSRC_'.$objDC->field.'" name="orderSRC_'.$objDC->field.'" value="'.$varValue.'">';
  846.                     $str .= '<script>Backend.makeMultiSrcSortable("sort_'.$objDC->field.'", "ctrl_orderSRC_'.$objDC->field.'")</script>';
  847.                     
  848.                     $strBuffer = str_replace($result[0], $str, $strBuffer);
  849.                 }
  850.             }
  851.         }
  852.         
  853.         // handle wizards (taken from DataContainer.php)
  854.         $wizard = '';
  855.         if ( isset($arrFieldDef['wizard']) && is_array($arrFieldDef['wizard']))
  856.         {
  857.             foreach ($arrFieldDef['wizard'] as $callback)
  858.             {
  859.                 $dc = clone($objDC);
  860.                 $dc->strField = $objDC->field;
  861.                 $dc->strInputName = $objDC->field;
  862.                 
  863.                 if (is_array($callback))
  864.                 {
  865.                     $objCallback = new $callback[0];
  866.                     $wizard .= $objCallback->{$callback[1]}($dc);
  867.                 }
  868.                 elseif (is_callable($callback))
  869.                 {
  870.                     $wizard .= $callback($dc);
  871.                 }
  872.             }
  873.             
  874.             if(strlen($wizard) > 0)
  875.             {
  876.                 $objWidget->wizard = $wizard;
  877.                 $strBuffer .= $wizard;
  878.             }
  879.         }
  880.         
  881.         if(strlen($strBuffer) > 0)
  882.         {
  883.             if(!strlen(strpos('tl_help tl_tip', $strBuffer)) && strlen($objWidget->description) > 0)
  884.             {
  885.                 $strBuffer .= '<p class="tl_help tl_tip">'.$objWidget->description.'</p>';
  886.             }
  887.         }
  888.         
  889.         // add the loadCustomElementFields flag if the attribute opens popups
  890.         if( (isset($arrFieldDef['isPopup']) && $arrFieldDef['isPopup'] == true) || in_array($arrFieldDef['inputType'], array('fileTree', 'pageTree')) )
  891.         {
  892.             $objSession = \Contao\System::getContainer()->get('session');
  894.             $arrSession = $objSession->get('loadCustomElementFields');
  895.             if(!is_array($arrSession))
  896.             {
  897.                 $arrSession = array();
  898.             }
  899.             $arrSession[] = $objDC->field;
  900.             
  901.             $objSession->set('loadCustomElementFields', array_unique( array_filter( $arrSession) ) );
  902.         }
  903.         
  904.         
  905.         $objFieldTemplate = new \Contao\BackendTemplate($this->strFieldTemplate);
  906.         $objFieldTemplate->setData($this->getData());
  907.         $arrClass = array($arrFieldDef['eval']['tl_class'] ?? '' );
  908.         #$arrClass[] = $objDC->field;
  909.         $arrClass[] = 'uuid_'.$objDC->field;
  910.         if( isset($arrFieldDef['eval']['chosen']) ) {$arrClass[] = 'chosen';}
  911.         $objFieldTemplate->cssID = 'id="'.$objDC->field.'"';
  912.         $objFieldTemplate->class = trim(implode(' ', $arrClass));
  913.         $objFieldTemplate->html = $strBuffer;
  914.         
  915.         // add data-attributes
  916.         $arrDataAttributes = array
  917.         (
  918.             'data-attr_id'        => $this->get('id'),
  919.             'data-attr_uuid'    => $this->get('uuid'),
  920.         );
  921.         $strDataAttributes = '';
  922.         foreach($arrDataAttributes as $k => $v)
  923.         {
  924.             $strDataAttributes .= $k.'="'.$v.'" ';
  925.         }
  926.         $objFieldTemplate->data_attributes = $strDataAttributes;
  927.         
  928.         // add to output list
  929.         $arrOutput[] = $objFieldTemplate->parse();
  930.         
  931.         //! generate the child attributes
  932.         if($this->hasChilds())
  933.         {
  934.             $arrChilds = $this->get('arrChildAttributes');
  935.             foreach($arrChilds as $name => $objChildWidget)
  936.             {
  937.                 $objChildWidget->value = $this->loadValue($objChildWidget->name,$objDC->id,$objDC->table,$objChildWidget->fieldDef);
  938.                 
  939.                 // save child widget information
  940.                 if(isset($_POST[$objChildWidget->name]) && !$this->get('doNotSave'))
  941.                 {
  942.                     $objChildWidget->validate();
  943.                     if($objChildWidget->hasErrors())
  944.                     {
  945.                         $objDC->noReload = true;
  946.                     }
  947.                     else
  948.                     {
  949.                         // save the value
  950.                         $varValue = \Contao\Input::post($objChildWidget->name);
  951.                         $this->saveValue($varValue,$objChildWidget->name,$objDC->id,$objDC->table,$objChildWidget->fieldDef);
  952.                     }
  953.                 }
  954.                 
  955.                 $strChild = $objChildWidget->parse();
  956.                 
  957.                 // handle wizards in child attributes
  958.                 if(!empty($objChildWidget->fieldDef['wizard']) && is_array($objChildWidget->fieldDef['wizard']))
  959.                 {
  960.                     foreach($objChildWidget->fieldDef['wizard'] as $callback)
  961.                     {
  962.                         $objCaller = new $callback[0];
  963.                         $objGenericDC = clone($objDC);
  964.                         $objGenericDC->field = $objChildWidget->name;
  965.                         $strChild .= $objCaller->{$callback[1]}($objGenericDC);
  966.                     }
  967.                 }
  968.                 
  969.                 if(strlen($objChildWidget->description) > 0)
  970.                 {
  971.                     $strChild .= '<p class="tl_help tl_tip">'.$objChildWidget->description.'</p>';
  972.                 }
  973.                 
  974.                 $objFieldTemplate = new \Contao\BackendTemplate($this->strFieldTemplate);
  975.                 $arrClass = array($objChildWidget->fieldDef['eval']['tl_class']);
  976.                 $objFieldTemplate->class = trim(implode(' ', $arrClass));
  977.                 $objFieldTemplate->html = $strChild;
  978.                 
  979.                 // add data-attributes
  980.                 $arrDataAttributes = array
  981.                 (
  982.                     'data-attr_id'        => $this->get('id'),
  983.                     'data-attr_uuid'    => $objChildWidget->name,
  984.                 );
  985.                 $strDataAttributes = '';
  986.                 foreach($arrDataAttributes as $k => $v)
  987.                 {
  988.                     $strDataAttributes .= $k.'="'.$v.'" ';
  989.                 }
  990.                 $objFieldTemplate->data_attributes = $strDataAttributes;
  991.                 
  992.                 $arrOutput[] = $objFieldTemplate->parse();
  993.             }
  994.         }
  995.         
  996.         $strBuffer = implode('', $arrOutput);
  997.         
  998.         // wrap widgets with child attributes in a seperate div
  999.         if($this->hasChilds())
  1000.         {
  1001.             $strBuffer = '<div class="field_group '.$this->get('uuid').'">'.$strBuffer.'<div class="clear"></div></div>';
  1002.         }
  1003.         
  1004.         $objWidget->buffer = $strBuffer;        
  1005.     
  1006.         // allow manipulations on the widget after it gets parsed
  1007.         $strBufferFromHook = \PCT\CustomElements\Core\Hooks::callstatic('parseWidgetHook',array($objWidget,$objDC->field,$arrFieldDef,$objDC));
  1008.         if(strlen($strBufferFromHook))
  1009.         {
  1010.             $strBuffer = $strBufferFromHook;
  1011.         }
  1012.         
  1013.         return $strBuffer;
  1014.     }
  1016.         
  1017.     /**
  1018.      * Prepare an attribute for DCA
  1019.      * @param object
  1020.      * @return array
  1021.      */
  1022.     public function prepareForDca($objDC)
  1023.     {
  1024.         // create a clone of the current datacontainer object to allow custom manipulations on the data container without interfering other fields
  1025.         $objDC = clone($objDC);
  1026.         
  1027.         $strName = $this->get('uuid');
  1028.         $strAlias = $this->get('alias');
  1029.         
  1030.         // generate a new unique id for a cloned attribute
  1031.         if( isset($this->createCopy) && (boolean)$this->createCopy === true )
  1032.         {
  1033.             $this->isCopy = 1;
  1034.             $numCopy = $this->numCopy ? $this->numCopy : 1;
  1035.             $objDC->pattr_uuid = $strName;
  1036.             $objDC->ref_table = 'tl_pct_customelement_attribute';
  1037.             // check if a uuid has been created by javascript already
  1038.             if(\Contao\Input::get('ajax') && \Contao\Input::get('uuids') )
  1039.             {
  1040.                 $arrUuids = \json_decode(StringUtil::decodeEntities(\Contao\Input::get('uuids')),true);
  1041.                 $strName = $arrUuids[$this->get('id')];
  1042.             }
  1043.             else
  1044.             {
  1045.                 $strName = AttributeFactory::generateUuid($objDC);
  1046.             }
  1047.             
  1048.             $strAlias = $this->get('alias').'#'.$numCopy;
  1049.         }
  1050.         
  1051.         // set the new field name
  1052.         $objDC->field = $strName;
  1053.         
  1054.         // get the field definition for this attribute
  1055.         $arrData = $this->getFieldDefinition();
  1056.         
  1057.         // translate the labels and descriptions
  1058.         $arrTranslatedLabel = $this->getTranslatedLabel();
  1059.         if(is_array($arrTranslatedLabel)) 
  1060.         {
  1061.             $arrData['label'] = $arrTranslatedLabel;
  1062.         }
  1063.         
  1064.         // HOOK: allow other extensions to manupulate the attribute Data Container array
  1065.         $arrData = \PCT\CustomElements\Core\Hooks::callstatic('getDcaHook',array($arrData,$this,$objDC));
  1066.         
  1067.         $arrReturn = array
  1068.         (
  1069.             'name'        => $strName,
  1070.             'alias'        => $strAlias,
  1071.             'id'        => $this->get('id'),
  1072.             'fieldDef'    => $arrData,
  1073.         );
  1075.         if( !is_array($arrReturn) )
  1076.         {
  1077.             $arrReturn = (array)$arrReturn;
  1078.         }
  1079.         
  1080.         // mark field as copy
  1081.         if( isset($this->createCopy) || isset($this->isCopy) )
  1082.         {
  1083.             $arrReturn['isCopy'] = 1;
  1084.             $arrReturn['pattr_uuid'] = $this->get('uuid');
  1085.         }
  1086.         
  1087.         // generate the html output
  1088.         if(!\Contao\Input::get('switch') && !\Contao\Input::get('show') && \Contao\Input::get('act') == 'edit')
  1089.         {
  1090.             $arrReturn['html'] = $this->generateWidget($objDC);
  1091.         }
  1092.         
  1093.         // HOOK: allow other extensions to manupulate the attribute output
  1094.         $arrReturn = \PCT\CustomElements\Core\Hooks::callstatic('prepareForDcaHook',array($arrReturn,$this,$objDC));
  1095.         
  1096.         return $arrReturn;
  1097.     }
  1098.     
  1099.     
  1100.     /**
  1101.      * Return true if the attribute has child attributes
  1102.      * @return boolean
  1103.      */
  1104.     public function hasChilds()
  1105.     {
  1106.         $arrChilds = $this->get('arrChildAttributes');
  1107.         if(!empty($arrChilds)) {return true;}
  1108.         return false;
  1109.     }
  1110.     
  1111.     
  1112.     /**
  1113.      * Return true if the attribute is a child attribute
  1114.      * @return boolean
  1115.      */
  1116.     public function isChild($strField)
  1117.     {
  1118.         // custom catalog field without underscore
  1119.         if($strField == $this->get('alias'))
  1120.         {
  1121.             return false;
  1122.         }
  1123.         
  1124.         if(strlen(strpos($strField, '_')) > 0)
  1125.         {
  1126.             $arrField = explode('_', $strField);
  1127.             // custom catalog field with underscore
  1128.             if(in_array($this->get('alias'), $arrField))
  1129.             {
  1130.                 return false;
  1131.             }
  1132.                         
  1133.             return true;
  1134.         }
  1135.         return false;
  1136.     }
  1137.     
  1138.     
  1139.     /**
  1140.      * Return the custom element object
  1141.      * @return object
  1142.      */
  1143.     public function getCustomElement()
  1144.     {
  1145.         if($this->get('objCustomElement'))
  1146.         {
  1147.             return $this->get('objCustomElement');
  1148.         }
  1149.         
  1150.         $objOrigin = $this->getOrigin();
  1151.         if($objOrigin)
  1152.         {
  1153.             $objCustomElement = $objOrigin->getCustomElement();
  1154.         }
  1155.         
  1156.         if(!isset($objCustomElement))
  1157.         {
  1158.             $objCustomElement = \PCT\CustomElements\Core\CustomElementFactory::findByAttributeId($this->get('id'));
  1159.         }
  1160.         
  1161.         $this->set('objCustomElement',$objCustomElement);
  1162.         
  1163.         return $objCustomElement;
  1164.     }
  1167.     /**
  1168.      * Add a child attribute to the list
  1169.      * @param object    Widget
  1170.      * @return array
  1171.      */
  1172.     public function addChildAttribute($objAttribute)
  1173.     {
  1174.         $arrChilds = $this->get('arrChildAttributes');
  1175.         $arrChilds[] = $objAttribute;
  1176.         $this->set('arrChildAttributes',$arrChilds);
  1177.     }
  1180.     /**
  1181.      * Add a child attribute to the list
  1182.      * @param array
  1183.      * @return object
  1184.      */
  1185.     public function prepareChildAttribute($arrFieldDef,$strName)
  1186.     {
  1187.         $strClass = $GLOBALS['BE_FFL'][$arrFieldDef['inputType']];
  1188.         if($strClass === null)
  1189.         {
  1190.             return null;
  1191.         }
  1193.         $objDC = $this->get('dataContainer') ?? null;
  1194.         if( isset($arrFieldDef['dataContainer']) )
  1195.         {
  1196.             $objDC = $arrFieldDef['dataContainer'];
  1197.         }
  1198.         
  1199.         $arrAttributes = $strClass::getAttributesFromDca($arrFieldDef,$strName,'',$strName,$objDC->table,$objDC);
  1200.         $objWidget = new $strClass($arrAttributes);
  1201.         $objWidget->fieldDef = $arrFieldDef;
  1202.         
  1203.         if( isset($arrFieldDef['eval']['dcaPicker']) && strlen($objWidget->wizard) < 1)
  1204.         {
  1205.             $objWidget->wizard = \Contao\Backend::getDcaPickerWizard($arrFieldDef['eval']['dcaPicker'], $objDC->table, $strName, $strName);
  1206.         }
  1208.         // add the attribute to the child list
  1209.         $this->addChildAttribute($objWidget);
  1210.         
  1211.         return $objWidget;
  1212.     }
  1215.     /**
  1216.      * Return the evaluation array
  1217.      * @param array
  1218.      * @return array
  1219.      */
  1220.     public function getEval($arrEvalMerge = array())
  1221.     {
  1222.         $arrReturn = array();
  1223.         $arrSystemCols = AttributeFactory::getSystemColumns();
  1224.         
  1225.         $arrTlClass = array();
  1226.         foreach($this->arrData as $strKey => $varValue)
  1227.         {
  1228.             if(in_array($strKey, $arrSystemCols) || !$varValue)
  1229.             {
  1230.                 continue;
  1231.             }
  1232.             
  1233.             if(strlen(strpos($strKey,'eval')))
  1234.             {
  1235.                 $k = ltrim($strKey,'eval');
  1236.                 $k = ltrim($k,'_');
  1237.                 #$k = strtolower($k);
  1238.                 
  1239.                 // handle tl_class
  1240.                 if(strlen(strpos($k,'tl_class')))
  1241.                 {
  1242.                     $varValue = str_replace('tl_class_', '', $k);
  1243.                     $arrTlClass[] = $varValue;
  1244.                     continue;
  1245.                 }
  1246.                 
  1247.                 // handle tl_style
  1248.                 if(strlen(strpos($k,'tl_style')))
  1249.                 {
  1250.                     $k = 'style';
  1251.                 }
  1252.                 
  1253.                 $arrReturn[$k] = $varValue;
  1254.             }
  1255.         }
  1256.         
  1257.         if(count($arrEvalMerge) > 0)
  1258.         {
  1259.             $arrReturn = array_unique(array_merge($arrReturn, $arrEvalMerge));
  1260.         }
  1261.                 
  1262.         if(count($arrTlClass) > 0)
  1263.         {
  1264.             if( isset($arrEvalMerge['tl_class']) && !empty($arrEvalMerge['tl_class']) )
  1265.             {
  1266.                 $class = explode(' ', $arrEvalMerge['tl_class']);
  1267.                 $arrTlClass = array_unique(array_merge($class));
  1268.             }
  1269.             
  1270.             $arrReturn['tl_class'] = implode(' ', $arrTlClass);
  1271.         }
  1273.         if( isset($arrReturn['path']) )
  1274.         {
  1275.             $objFile = \Contao\FilesModel::findByPk( trim($arrReturn['path']) );
  1276.             if( $objFile !== null )
  1277.             {    
  1278.                 $arrReturn['path'] = $objFile->path;    
  1279.             }
  1280.             else
  1281.             {
  1282.                 unset( $arrReturn['path'] );
  1283.             }
  1284.         }
  1285.         
  1286.         return $arrReturn;
  1287.     }
  1288.     
  1290. //! --- Frontend output ---    
  1293.     /**
  1294.      * Render the attribute and return html string
  1295.      * @return string
  1296.      */
  1297.     public function render()
  1298.     {
  1299.         $objOrigin = $this->get('objOrigin');
  1300.         
  1301.         $strField = $this->get('uuid');
  1302.         
  1303.         $strTemplate = $this->get('template');
  1304.         
  1305.         // set default template
  1306.         if( empty($strTemplate) )
  1307.         {
  1308.             $strTemplate = 'customelement_attr_default';
  1309.             $this->set('template',$strTemplate);
  1310.         }
  1311.         
  1312.         // check if we use a regular contao template or custom template
  1313.         if(strlen(strpos($strTemplate, 'customelement_attr')) < 1)
  1314.         {
  1315.             $this->isCustomTemplate = true;
  1316.         }
  1317.         
  1318.         $objTemplate = new FrontendTemplate($strTemplate);
  1319.         $objTemplate->setData($this->get('arrData'));
  1320.         $objTemplate->origin = $objOrigin;
  1321.         
  1322.         // check if the attribute has not been modified from outside
  1323.         if($objOrigin != null && !$this->isModified('varValue'))
  1324.         {
  1325.             $varValue = $this->loadValue($strField,$objOrigin::get('pid'),$objOrigin::get('table'));
  1326.         }
  1327.         else
  1328.         {
  1329.             $varValue = $this->getValue();
  1330.         }
  1331.         
  1332.         $objTemplate->value = $varValue;
  1333.         
  1334.         // add raw values
  1335.         $objTemplate->rawValue = $varValue;
  1336.         $objTemplate->raw = $this;
  1337.         $objTemplate->attribute = $this;
  1338.         
  1339.         $arrCssID = \Contao\StringUtil::deserialize($this->get('cssID'));
  1340.         $objTemplate->cssID = $arrCssID[0] ? 'id="'.$arrCssID[0].'"' : '';
  1341.         $arrClass = array('ce_'.$this->get('type'),'attribute',$this->get('type'));
  1342.         if(strlen($arrCssID[1]) > 0)
  1343.         {
  1344.             $arrClass = array_merge($arrClass,explode(' ',$arrCssID[1]));
  1345.         }
  1346.         $objTemplate->class = implode(' ', $arrClass);
  1347.         
  1348.         // HOOK: alternative routine to renderCallback to render an attribute
  1349.         $strBufferFromHook = \PCT\CustomElements\Core\Hooks::callstatic('prepareRenderingHook',array($strField,$varValue,$objTemplate,$this));
  1350.         
  1351.         // check if the attribute itself calls its render function
  1352.         if(method_exists($this, 'renderCallback') && strlen($strBufferFromHook) < 1)
  1353.         {
  1354.             $strBuffer = \call_user_func_array(array($this, 'renderCallback'), array($strField,$varValue,$objTemplate,$this) );
  1355.         }
  1356.         else if(strlen($strBufferFromHook) > 0)
  1357.         {
  1358.             $strBuffer = $strBufferFromHook;
  1359.             $strBufferFromHook = '';
  1360.         }
  1361.         else
  1362.         {
  1363.             $strBuffer = $objTemplate->parse();
  1364.         }
  1365.         
  1366.         // trigger HOOK: allow manipulations on the output
  1367.         $strBufferFromHook = \PCT\CustomElements\Core\Hooks::callstatic('renderAttributeHook',array($strBuffer,$strField,$varValue,$this));
  1368.         if(strlen($strBufferFromHook) > 0)
  1369.         {
  1370.             $strBuffer = $strBufferFromHook;
  1371.         }
  1372.         
  1373.         return $strBuffer;
  1374.     }
  1377. //! --- translations and multilanguage support ---
  1380.     /**
  1381.      * Find translations for labels in the backend and return them as array
  1382.      * @param string
  1383.      * @param object
  1384.      * @return null|array
  1385.      */
  1386.     public function getTranslatedLabel()
  1387.     {
  1388.         $arrReturn = array();
  1389.         $strKey = $this->getCustomElement()->get('alias');
  1390.         $strField = $this->get('alias');
  1391.         
  1392.         \Contao\System::loadLanguageFile('default',$GLOBALS['TL_LANGUAGE']);
  1393.         
  1394.         // fallback
  1395.         if( isset($GLOBALS['TL_LANG'][$strKey][$strField]) && is_array($GLOBALS['TL_LANG'][$strKey][$strField]))
  1396.         {
  1397.             $arrReturn = array($GLOBALS['TL_LANG'][$strKey][$strField][0] ?: '',$GLOBALS['TL_LANG'][$strKey][$strField][1] ?: '');
  1398.         }
  1399.         
  1400.         // new structure
  1401.         if( isset($GLOBALS['TL_LANG']['CUSTOMELEMENTS'][$strKey]['fields'][$strField]) && ( is_array($GLOBALS['TL_LANG']['CUSTOMELEMENTS'][$strKey]['fields'][$strField]) || is_array($GLOBALS['TL_LANG']['CUSTOMELEMENTS']['*']['fields'][$strField]) ) )
  1402.         {
  1403.             $arrReturn = $GLOBALS['TL_LANG']['CUSTOMELEMENTS'][$strKey]['fields'][$strField] ?: is_array($GLOBALS['TL_LANG']['CUSTOMELEMENTS']['*']['fields'][$strField]);
  1404.         }
  1405.         
  1406.         return $arrReturn;
  1407.     }
  1409.     
  1410.     /**
  1411.      * Return the translations array
  1412.      * @return array
  1413.      */
  1414.     public function getTranslations()
  1415.     {
  1416.         return $this->get('arrTranslations');
  1417.     }
  1418.     
  1419.     
  1420.     /**
  1421.      * Add a translation for a value to the labels array
  1422.      * @param string    Value key
  1423.      * @param string    Label
  1424.      * @param string    The language code e.g. de, en...
  1425.      */
  1426.     public function addTranslation($strValue,$strLabel,$strLanguage)
  1427.     {
  1428.         // mark as modified    
  1429.         $this->setModified('arrTranslations');
  1430.         
  1431.         $arrTranslations = $this->get('arrTranslations');
  1432.         
  1433.         // set the translated label for the language
  1434.         $arrTranslations[$strValue][$strLanguage] = $strLabel;
  1435.         
  1436.         $this->set('arrTranslations',$arrTranslations);
  1437.     }
  1438.     
  1439.     
  1440.     
  1441.     /**
  1442.      * Return boolean true if a value has a translation and set the translated value for further use
  1443.      * @param string
  1444.      * @return boolean
  1445.      */
  1446.     public function hasTranslation($strValue,$strLanguage='')
  1447.     {
  1448.         if(strlen($strLanguage) < 1)
  1449.         {
  1450.             $strLanguage = \Contao\Input::get('language') ?: \Contao\Input::get('lang') ?: $GLOBALS['TL_LANGUAGE'];
  1451.         }
  1452.         
  1453.         // replace the minus with an underscore
  1454.         if($strLanguage == $GLOBALS['TL_LANGUAGE'] && TL_MODE == 'FE')
  1455.         {
  1456.             $strLanguage = str_replace('-','_',$strLanguage);
  1457.         }
  1459.         \Contao\System::loadLanguageFile('default',$strLanguage);
  1460.         
  1461.         $arrTranslations = $this->getTranslations();
  1462.         $strKey = $this->getCustomElement()->get('alias');
  1463.         $strField = $this->get('alias');
  1464.         
  1465.         // look in global language array
  1466.         if(isset($GLOBALS['TL_LANG'][$strKey][$strField][$strValue]))
  1467.         {
  1468.             $this->setTranslatedValue($strValue,$GLOBALS['TL_LANG'][$strKey][$strField][$strValue],$strLanguage);
  1469.             $this->addTranslation($strValue,$GLOBALS['TL_LANG'][$strKey][$strField][$strValue],$strLanguage);
  1470.         }
  1471.         else
  1472.         {
  1473.             // hook here
  1474.             $strTranslation = \PCT\CustomElements\Core\Hooks::callstatic('translateValueHook',array($strField,$strValue,$strKey,$this) );
  1475.             if( !empty($strTranslation) )
  1476.             {
  1477.                 $this->setTranslatedValue($strValue,$strTranslation,$strLanguage);
  1478.                 $this->addTranslation($strValue,$GLOBALS['TL_LANG'][$strKey][$strField][$strValue],$strLanguage);
  1479.             }
  1480.         }
  1482.         if(isset($arrTranslations[$strValue][$strLanguage]))
  1483.         {
  1484.             return true;
  1485.         }
  1486.         
  1487.         return false;
  1488.     }
  1489.     
  1490.     
  1491.     /**
  1492.      * Return the translated value
  1493.      * @param string
  1494.      * @param string
  1495.      */
  1496.     public function getTranslatedValue($strValue,$strLanguage='')
  1497.     {
  1498.         if(strlen($strLanguage) < 1)
  1499.         {
  1500.             $strLanguage = \Contao\Input::get('language') ?: \Contao\Input::get('lang') ?: $GLOBALS['TL_LANGUAGE'];
  1501.         }
  1502.         
  1503.         // replace the minus with an underscore
  1504.         if($strLanguage == $GLOBALS['TL_LANGUAGE'] && TL_MODE == 'FE')
  1505.         {
  1506.             $strLanguage = str_replace('-','_',$strLanguage);
  1507.         }
  1508.         
  1509.         // search for the translation
  1510.         if(!$this->hasTranslation($strValue,$strLanguage))
  1511.         {
  1512.             return $strValue;
  1513.         }
  1514.         
  1515.         $arrTranslations = $this->getTranslations();
  1517.         return $arrTranslations[$strValue][$strLanguage];
  1518.     }
  1519.     
  1520.     
  1521.     /**
  1522.      * Set the translated value
  1523.      * @param string
  1524.      * @param string
  1525.      */
  1526.     public function setTranslatedValue($strValue,$strTranslation,$strLanguage='')
  1527.     {
  1528.         if(strlen($strLanguage) < 1)
  1529.         {
  1530.             $strLanguage = \Contao\Input::get('language') ?: \Contao\Input::get('lang') ?: $GLOBALS['TL_LANGUAGE'];
  1531.         }
  1532.         $this->addTranslation($strValue,$strTranslation,$strLanguage);
  1533.     }
  1536.     /**
  1537.      * Check the access rights of the user
  1538.      * @return boolean
  1539.      */
  1540.     public function hasAccess()
  1541.     {
  1542.         if(TL_MODE == 'FE' || !$this->get('protected'))
  1543.         {
  1544.             return true;
  1545.         }
  1546.         
  1547.         $objUser = \Contao\BackendUser::getInstance();
  1548.         
  1549.         if($objUser->isAdmin)
  1550.         {
  1551.             return true;
  1552.         }
  1553.         
  1554.         // check if user has group access
  1555.         $usergroups = \Contao\StringUtil::deserialize($this->get('user_groups'));
  1556.         if(!empty($usergroups) && is_array($usergroups))
  1557.         {
  1558.             foreach($usergroups as $group)
  1559.             {
  1560.                 if(in_array($group, \Contao\StringUtil::deserialize($objUser->groups) ?: array()) )
  1561.                 {
  1562.                     return true;
  1563.                 }
  1564.             }
  1565.         }
  1566.         
  1567.         // check if user itself has access
  1568.         $users = \Contao\StringUtil::deserialize($this->get('users'));
  1569.         if(!empty($users) && is_array($users))
  1570.         {
  1571.             if(in_array($objUser->id,$users))
  1572.             {
  1573.                 return true;
  1574.             }
  1575.         }
  1576.         
  1577.         return false;
  1578.     }
  1579. }