system/modules/pct_customelements/PCT/CustomElements/Core/AttributeFactory.php line 43

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\Database;
  24. use Contao\StringUtil;
  25. use PCT\CustomElements\Core\Origin as Origin;
  26. use PCT\CustomElements\Helper\QueryBuilder as QueryBuilder;
  27. use PCT\CustomElements\Helper\ControllerHelper as ControllerHelper;
  28. use PCT\CustomElements\Core\Cache as Cache;
  29. use PCT\CustomElements\Models\AttributeModel as AttributeModel;
  31. /**
  32.  * Class file
  33.  * AttributeFactory
  34.  * Generate attributes
  35.  */
  36. class AttributeFactory
  37. {
  38.     /**
  39.      * Create a CustomElement object instance by a model instance
  40.      * @param object    Model or DatabaseResult
  41.      * @return object    \PCT\CustomElements\Core\CustomElement
  42.      */
  43.     public static function create($objModel)
  44.     {
  45.         // if a database result is coming
  46.         if(strlen(strpos(get_class($objModel), 'Database')) > 0 && strlen(strpos(get_class($objModel), 'Result')) > 0)
  47.         {
  48.             $objModel = new AttributeModel($objModel,false);
  49.         }
  51.         if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['ATTRIBUTES'][$objModel->type]) )
  52.         {
  53.             return null;
  54.         }
  55.         
  56.         $strClass = $GLOBALS['PCT_CUSTOMELEMENTS']['ATTRIBUTES'][$objModel->type]['class'];
  57.         if(strlen($strClass) < 1)
  58.         {
  59.             return null;
  60.         }
  61.         
  62.         if(!class_exists($strClass))
  63.         {
  64.             \PCT\CustomElements\Loader\AttributeLoader::load($objModel->type);
  65.         }
  66.         
  67.         try
  68.         {
  69.             if(!class_exists($strClass))
  70.             {
  71.                 throw new \Exception('Cannot load Attribute class or class not found: '.$strClass);
  72.             }
  73.             
  74.         }
  75.         catch(\Exception $e)
  76.         {
  77.             throw new \Exception($e->getMessage());
  78.         }
  79.         
  80.         $objReturn = new $strClass( $objModel->row() );
  81.         $objReturn->setModel($objModel);
  82.         
  83.         // trigger the onFactoryCreate Hook
  84.         \PCT\CustomElements\Core\Hooks::callstatic('onFactoryCreateHook',array($objReturn,$objModel));
  85.         
  86.         return $objReturn;
  87.     }
  88.     
  89.     
  90.     /**
  91.      * Find all active attributes and return as array
  92.      * @return array
  93.      */
  94.     public static function findAll()
  95.     {
  96.         $objCollection = AttributeModel::findAll();
  97.         if($objCollection === null)
  98.         {
  99.             return array();
  100.         }
  101.         
  102.         $objRegistry = \Contao\Model\Registry::getInstance();
  103.         
  104.         $arrReturn = array();
  105.         foreach($objCollection as $objModel)
  106.         {
  107.             $objAttribute = static::create( $objModel );
  108.             if($objAttribute === null)
  109.             {
  110.                 continue;
  111.             }
  112.             
  113.             $arrReturn[] = $objAttribute;
  114.             
  115.             // add to cache
  116.             Cache::addAttribute($objAttribute->id,$objAttribute);
  117.             Cache::addAttribute($objAttribute->uuid,$objAttribute);
  118.         }
  119.         
  120.         return $arrReturn;
  121.     }
  122.     
  123.     
  124.     /**
  125.      * Find a CustomElement instance by an ID
  126.      * @param id
  127.      * @return object    Filter instance
  128.      */
  129.     public static function findById($intId, $arrOptions=array())
  130.     {
  131.         // look up from Cache
  132.         if(Cache::getAttribute($intId))
  133.         {
  134.             return Cache::getAttribute($intId);
  135.         }
  136.         
  137.         $objModel = AttributeModel::findByPk($intId,$arrOptions);
  138.         if($objModel === null)
  139.         {
  140.             return null;
  141.         }
  142.         
  143.         $objReturn = static::create( $objModel );
  144.         if($objReturn === null)
  145.         {
  146.             return null;
  147.         }
  148.         
  149.         // add to cache
  150.         Cache::addAttribute($objReturn->id, $objReturn);
  151.         Cache::addAttribute($objReturn->uuid, $objReturn);
  153.         return $objReturn;
  154.     }
  155.     
  156.     
  157.     /**
  158.      * Fetch an attribute by its id
  159.      * @param integer
  160.      * @return object    \PCT\CustomElements\Models\AttributeModel
  161.      */
  162.     public static function fetchById($intId, $arrOptions=array())
  163.     {
  164.         return AttributeModel::findByPk($intId, $arrOptions);    
  165.     }
  166.     
  167.     
  168.     /**
  169.      * Generate the published attribute by a given id return the Attribute object
  170.      * @param integer
  171.      * @return object Attribute
  172.      */
  173.     public static function findPublishedById($intId, $arrOptions=array())
  174.     {
  175.         // look up from Cache
  176.         if(Cache::getAttribute($intId))
  177.         {
  178.             $objReturn = Cache::getAttribute($intId);
  179.             if((boolean)$objReturn->get('published') === false )
  180.             {
  181.                 return null;
  182.             }
  183.             return $objReturn;
  184.         }
  185.             
  186.         $objModel = AttributeModel::findPublishedById($intId,$arrOptions);
  187.         if($objModel === null)
  188.         {
  189.             return null;
  190.         }
  191.         
  192.         $objReturn = static::create( $objModel );
  193.         if($objReturn === null)
  194.         {
  195.             return null;
  196.         }
  197.         
  198.         // add to cache
  199.         Cache::addAttribute($objReturn->id, $objReturn);
  200.         Cache::addAttribute($objReturn->uuid, $objReturn);
  201.         
  202.         return $objReturn;
  203. }
  204.     
  205.     
  206.     /**
  207.      * Fetch the published attribute by a given id return the database result object
  208.      * @param integer
  209.      * @return object Attribute
  210.      */
  211.     public static function fetchPublishedById($intId, $arrOptions=array())
  212.     {
  213.         return AttributeModel::findPublishedById($intId, $arrOptions);
  214.     }
  215.     
  216.     
  217.     /**
  218.      * Fetch the attributes by a given set of ids return the database result object
  219.      * @param integer
  220.      * @return object Attribute
  221.      */
  222.     public static function fetchMultipleById($arrIds, $arrOptions=array())
  223.     {
  224.         if (!isset($arrOptions['order']))
  225.         {
  226.             $arrOptions['order'] = "tl_pct_customelement_attribute.sorting";
  227.         }
  228.         
  229.         return AttributeModel::findMultipleByIds($arrIds,$arrOptions);
  230.     }
  231.     
  232.     
  233.     /**
  234.      * Generate the attribute by a given id return the Attribute object
  235.      * @param integer
  236.      * @return object Attribute
  237.      */
  238.     public static function findByUuid($strUuid, $arrOptions=array())
  239.     {
  240.         // look up from Cache
  241.         if(Cache::getAttribute($strUuid))
  242.         {
  243.             return Cache::getAttribute($strUuid);
  244.         }
  245.         
  246.         $objModel = AttributeModel::findByUuid($strUuid,$arrOptions);
  247.         if($objModel === null)
  248.         {
  249.             return null;
  250.         }
  251.         
  252.         $objReturn = static::create( $objModel );
  253.         if($objReturn === null)
  254.         {
  255.             return null;
  256.         }
  257.         
  258.         // add to cache
  259.         Cache::addAttribute($objReturn->id, $objReturn);
  260.         Cache::addAttribute($strUuid, $objReturn);
  261.         
  262.         return $objReturn;
  263.     }
  264.     
  265.     
  266.     /**
  267.      * Generate the attribute by a given alias return the Attribute object
  268.      * @param integer
  269.      * @return object Attribute
  270.      */
  271.     public static function findByAlias($strAlias, $arrOptions=array())
  272.     {
  273.         $objModel = AttributeModel::findByAlias($strAlias,$arrOptions);
  274.         if($objModel === null)
  275.         {
  276.             return null;
  277.         }
  278.         
  279.         $objReturn = static::create( $objModel );
  280.         if($objReturn === null)
  281.         {
  282.             return null;
  283.         }
  284.         
  285.         // add to cache
  286.         Cache::addAttribute($objReturn->id, $objReturn);
  287.         Cache::addAttribute($objReturn->uuid, $objReturn);
  288.         
  289.         return $objReturn;
  290.     }
  291.     
  293.     /**
  294.      * Fetch the attribute by a given alias return the Attribute object
  295.      * @param integer
  296.      * @return object Attribute
  297.      */
  298.     public static function fetchByAlias($strAlias, $arrOptions=array())
  299.     {
  300.         return AttributeModel::findByAlias($strAlias,$arrOptions);    
  301.     }
  302.     
  303.     
  304.     /**
  305.      * Find an attribute by its alias in a customelement by ID or Alias
  306.      * @param string
  307.      * @param integer|string        Id or Alias of the CE
  308.      * @return object
  309.      */
  310.     public static function findByAliasAndCustomElement($strAlias,$varCE,$arrOptions=array())
  311.     {
  312.         // look up from cache
  313.         if(Cache::getAttribute('ce_'.$varCE.'_'.$strAlias))
  314.         {
  315.             return Cache::getAttribute('ce_'.$varCE.'_'.$strAlias);
  316.         }
  317.         
  318.         $objCE = \PCT\CustomElements\Core\CustomElementFactory::findByIdOrAlias($varCE,$arrOptions);
  319.         if($objCE === null)
  320.         {
  321.             return null;
  322.         }
  324.         // handle copies
  325.         $isCopy = false;
  326.         if(strlen(strpos($strAlias, '#')) > 0)
  327.         {
  328.             $arr = explode('#', $strAlias);
  329.             $strAlias = $arr[0];
  330.             $isCopy = true;
  331.         }
  332.         
  333.         $strCEwhere = "SELECT id FROM tl_pct_customelement WHERE id=".$objCE->id;
  334.         
  335.         $strQuery = "tl_pct_customelement_attribute.alias=? AND pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid IN(".$strCEwhere.") GROUP BY id)";
  336.         
  337.         $objCollection = AttributeModel::findByCustomSql($strQuery,array($strAlias));
  338.         if($objCollection === null)
  339.         {
  340.             return null;
  341.         }
  342.         
  343.         $arrModels = $objCollection->getModels();
  344.         
  345.         $objReturn = static::create( $arrModels[0] );
  346.         
  347.         // add to cache
  348.         Cache::addAttribute($objReturn->id, $objReturn);
  349.         Cache::addAttribute($objReturn->uuid, $objReturn);
  350.         Cache::addAttribute('ce_'.$objCE->id.'_'.$strAlias, $objReturn);
  351.         
  352.         return $objReturn;
  353.     }
  354.     
  355.     
  356.     /**
  357.      * Find an attribute by its uuid in a customelement by ID or Alias
  358.      * @param string
  359.      * @param integer|string        Id or Alias of the CE
  360.      * @return object
  361.      */
  362.     public static function findByUuidAndCustomElement($strUuid,$varCE,$arrOptions=array())
  363.     {
  364.         // look up from cache
  365.         if(Cache::getAttribute('ce_'.$varCE.'_'.$strUuid))
  366.         {
  367.             return Cache::getAttribute('ce_'.$varCE.'_'.$strUuid);
  368.         }
  369.         
  370.         $objCE = \PCT\CustomElements\Core\CustomElementFactory::findByIdOrAlias($varCE,$arrOptions);
  371.         if($objCE === null)
  372.         {
  373.             return null;
  374.         }
  376.         $strCEwhere = "SELECT id FROM tl_pct_customelement WHERE id=".$objCE->id;
  377.         
  378.         $strQuery = "tl_pct_customelement_attribute.uuid=? AND pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid IN(".$strCEwhere.") GROUP BY id)";
  379.         
  380.         $objCollection = AttributeModel::findByCustomSql($strQuery,array($strUuid));
  381.         if($objCollection === null)
  382.         {
  383.             return null;
  384.         }
  385.         
  386.         $arrModels = $objCollection->getModels();
  387.         
  388.         $objReturn = static::create( $arrModels[0] );
  389.         
  390.         // add to cache
  391.         Cache::addAttribute($objReturn->id, $objReturn);
  392.         Cache::addAttribute($objReturn->uuid, $objReturn);
  393.         Cache::addAttribute('ce_'.$objCE->id.'_'.$strUuid, $objReturn);
  394.         Cache::addAttribute('ce_'.$objCE->alias.'_'.$strUuid, $objReturn);
  395.         
  396.         return $objReturn;
  397.     }
  398.     
  399.     
  400.     /**
  401.      * Generate all attributes in a group and return them as array
  402.      * @param integer
  403.      * @return array
  404.      */
  405.     public static function findByParentId($intPid, $arrOptions=array())
  406.     {
  407.         $arrCache = Cache::getData();
  408.         
  409.         // look up from cache
  410.         $strKey = 'AttributeFactory::'.__FUNCTION__;
  411.         if(isset($arrCache['ATTRIBUTE'][$strKey][$intPid]) && $arrCache['ATTRIBUTE'][$strKey][$intPid] !== null)
  412.         {
  413.             return $arrCache['ATTRIBUTE'][$strKey][$intPid];
  414.         }
  415.         
  416.         
  417.         $objCollection = AttributeModel::findByPid($intPid,$arrOptions);
  418.         if($objCollection === null)
  419.         {
  420.             return null;
  421.         }
  422.         
  423.         $arrReturn = array();
  424.         foreach($objCollection as $objModel)
  425.         {
  426.             $objAttribute = static::create( $objModel );
  427.             if($objAttribute === null)
  428.             {
  429.                 continue;
  430.             }
  431.             
  432.             $arrReturn[] = $objAttribute;
  433.             
  434.             // add to cache
  435.             Cache::addAttribute($objAttribute->id, $objAttribute);
  436.             Cache::addAttribute($objAttribute->uuid, $objAttribute);
  437.             Cache::addAttribute('group_'.$intPid.'_'.$objAttribute->alias, $objAttribute);
  438.         }
  439.         
  440.         // add to cache
  441.         $arrCache['ATTRIBUTE'][$strKey][$intPid] = $arrReturn;
  442.         Cache::setData($arrCache);
  443.         
  444.         return $arrReturn;
  445.     }
  446.     
  447.     
  448.     /**
  449.      * Generate all attributes in a group and return them as array
  450.      * @param integer
  451.      * @return array
  452.      */
  453.     public static function findByAliasAndPid($strAlias, $intPid, $arrOptions=array())
  454.     {
  455.         // look up from cache
  456.         if(Cache::getAttribute('group_'.$intPid.'_'.$strAlias))
  457.         {
  458.             return Cache::getAttribute('group_'.$intPid.'_'.$strAlias);
  459.         }
  460.         
  461.         $objModel = AttributeModel::findByAliasAndPid($strAlias, $intPid,$arrOptions);
  462.         if($objModel === null)
  463.         {
  464.             return null;
  465.         }
  466.         
  467.         $objReturn = static::create( $objModel );
  468.         if($objReturn === null)
  469.         {
  470.             return null;
  471.         }
  472.         
  473.         // add to cache
  474.         Cache::addAttribute($objReturn->id, $objReturn);
  475.         Cache::addAttribute($objReturn->uuid, $objReturn);
  476.         Cache::addAttribute('group_'.$intPid.'_'.$objReturn->alias, $objReturn);
  478.         return $objReturn;
  480.     }
  481.     
  482.     
  483.     /**
  484.      * Generate all attributes in a group and return them as array
  485.      * @param integer
  486.      * @return array
  487.      */
  488.     public static function findPublishedByParentId($intPid, $arrOptions=array())
  489.     {
  490.         $arrCache = Cache::getData();
  491.         
  492.         // look up from cache
  493.         $strKey = 'AttributeFactory::'.__FUNCTION__;
  494.         if( isset($arrCache['ATTRIBUTE'][$strKey][$intPid]) && $arrCache['ATTRIBUTE'][$strKey][$intPid] !== null)
  495.         {
  496.             return $arrCache['ATTRIBUTE'][$strKey][$intPid];
  497.         }
  498.         
  499.         $objCollection = AttributeModel::findPublishedByPid($intPid, $arrOptions);
  500.         if($objCollection === null)
  501.         {
  502.             return array();
  503.         }
  504.         
  505.         $arrReturn = array();
  506.         foreach($objCollection as $objModel)
  507.         {
  508.             $objAttribute = static::create( $objModel );
  509.             if($objAttribute === null)
  510.             {
  511.                 continue;
  512.             }
  513.             
  514.             $arrReturn[] = $objAttribute;
  515.             
  516.             // add to cache
  517.             Cache::addAttribute($objAttribute->id, $objAttribute);
  518.             Cache::addAttribute($objAttribute->uuid, $objAttribute);
  519.             Cache::addAttribute('ce_'.$intPid.'_'.$objAttribute->alias, $objAttribute);
  520.         }
  521.         
  522.         // add to cache
  523.         $arrCache['ATTRIBUTE'][$strKey][$intPid] = $arrReturn;
  524.         Cache::setData($arrCache);
  525.         
  526.         return $arrReturn;
  527.     }
  528.     
  529.     
  530.     /**
  531.      * Return the attribute (mainly a copy) by its alias and origin information
  532.      * @param string
  533.      * @param integer
  534.      * @param string
  535.      * @return object
  536.      */
  537.     public static function findByAliasAndOrigin($strAlias,$intPid,$strTable)
  538.     {
  539.         $arrData = array();
  540.         
  541.         $objDatabase = Database::getInstance();
  543.         if(Cache::getWizard($intPid,$strTable))
  544.         {
  545.             $arrData = StringUtil::deserialize(Cache::getWizard($intPid,$strTable));
  546.         }
  547.         else if( $objDatabase->tableExists('tl_pct_customelement_vault') )
  548.         {
  549.             // check if there is a wizzard data for this record
  550.             $objWizard = \Contao\Database::getInstance()->prepare("SELECT * FROM tl_pct_customelement_vault WHERE pid=? AND source=? AND type=?")->limit(1)->execute($intPid,$strTable,'wizard');
  551.             if($objWizard->numRows < 1)
  552.             {
  553.                 return null;
  554.             }
  555.         
  556.             $arrData = StringUtil::deserialize($objWizard->data_blob);
  557.         }
  558.         
  559.         if(empty($arrData))
  560.         {
  561.             return null;
  562.         }
  563.         
  564.         foreach($arrData as $k => $data)
  565.         {
  566.             if(!is_array($data)) {continue;}
  567.             // work on copies only
  568.             if(!$data['isCopy'] || empty($data['attributes'])) {continue;}
  569.             foreach($data['attributes'] as $attribute)
  570.             {
  571.                 if($attribute['alias'] == $strAlias)
  572.                 {
  573.                     // generate parent attribute
  574.                     $objAttribute = AttributeFactory::findById($attribute['id']);
  575.                     // set uuid to copy uuid
  576.                     $objAttribute->set('uuid',$attribute['uuid']);
  577.                 }
  578.             }
  579.         }
  580.         
  581.         return $objAttribute;
  582.     }
  583.     
  584.     
  585.     /**
  586.      * Return the attribute by its uuid located in a wizard. Finds clones
  587.      * @param string
  588.      * @param integer
  589.      * @param string
  590.      * @return object|null
  591.      */
  592.     public static function findCloneByUuidAndOrigin($strUuid,$intPid,$strTable,$intAttribute=0)
  593.     {
  594.         $arrWizard = \PCT\CustomElements\Core\Vault::getWizardData($intPid,$strTable,$intAttribute);
  595.         if( isset($arrWizard['clones']) && is_array($arrWizard['clones']))
  596.         {
  597.             foreach($arrWizard['clones'] as $attr_id => $arrUuids)
  598.             {
  599.                 if(empty($arrUuids) || !is_array($arrUuids))
  600.                 {
  601.                     continue;
  602.                 }
  603.                 
  604.                 if(in_array($strUuid, $arrUuids))
  605.                 {
  606.                     return \PCT\CustomElements\Core\AttributeFactory::findById($attr_id);
  607.                 }
  608.             }
  609.         }
  610.         return null;
  611.     }
  612.     
  613.     
  614.     /**
  615.      * Find attributes by the custom element
  616.      * @param integer
  617.      * @return array
  618.      */
  619.     public static function findMultipleByCustomElement($intId, $arrOptions=array())
  620.     {
  621.         $arrCache = Cache::getData();
  622.         
  623.         $strKey = 'AttributeFactory::'.__FUNCTION__;
  624.         if( isset($arrCache['ATTRIBUTE'][$strKey][$intId]) && $arrCache['ATTRIBUTE'][$strKey][$intId] !== null)
  625.         {
  626.             return $arrCache['ATTRIBUTE'][$strKey][$intId];
  627.         }
  628.         
  629.         $strQuery = "tl_pct_customelement_attribute.pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid=".$intId.")";
  630.         $objCollection = AttributeModel::findByCustomSql($strQuery,array(),$arrOptions);
  631.         if($objCollection === null)
  632.         {
  633.             return array();
  634.         }
  635.         
  636.         $arrReturn = array();
  637.         foreach($objCollection as $objModel)
  638.         {
  639.             $arrReturn[] = static::create( $objModel );
  640.         }
  641.         
  642.         // add to cache
  643.         $arrCache['ATTRIBUTE'][$strKey][$intId] = $arrReturn;
  644.         Cache::setData($arrCache);
  645.         
  646.         return $arrReturn;
  647.     }
  648.     
  649.     
  650.     /**
  651.      * Find attributes by the custom element
  652.      * @param integer
  653.      * @return object    Database Result
  654.      */
  655.     public static function fetchMultipleByCustomElement($intId, $arrOptions=array())
  656.     {
  657.         $strQuery = "tl_pct_customelement_attribute.pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid=".$intId.")";
  658.         return AttributeModel::findByCustomSql($strQuery,array(),$arrOptions);
  659.     }
  660.     
  661.     
  662.     /**
  663.      * Find attributes by the custom element
  664.      * @param integer
  665.      * @return array
  666.      */
  667.     public static function findMultiplePublishedByCustomElement($intId, $arrOptions=array())
  668.     {
  669.         $arrCache = Cache::getData();
  670.         
  671.         $strKey = 'AttributeFactory::'.__FUNCTION__;
  672.         if($arrCache['ATTRIBUTE'][$strKey][$intId] !== null)
  673.         {
  674.             return $arrCache['ATTRIBUTE'][$strKey][$intId];
  675.         }
  676.         
  677.         $strQuery = "tl_pct_customelement_attribute.pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid=".$intId.") AND tl_pct_customelement_attribute.published=1";
  678.         $objCollection = AttributeModel::findByCustomSql($strQuery,array(),$arrOptions);
  679.         if($objCollection === null)
  680.         {
  681.             return array();
  682.         }
  683.         
  684.         $arrReturn = array();
  685.         foreach($objCollection as $objModel)
  686.         {
  687.             $arrReturn[] = static::create( $objModel );
  688.         }
  689.         
  690.         // add to cache
  691.         $arrCache['ATTRIBUTE'][$strKey][$intId] = $arrReturn;
  692.         Cache::setData($arrCache);
  693.         
  694.         return $arrReturn;
  695.     }
  696.     
  697.     
  698.     /**
  699.      * Find attributes by the custom element
  700.      * @param integer
  701.      * @return object    Database Result
  702.      */
  703.     public static function fetchMultiplePublishedByCustomElement($intId, $arrOptions=array())
  704.     {
  705.         $strQuery = "tl_pct_customelement_attribute.pid IN(SELECT id FROM tl_pct_customelement_group WHERE pid=".$intId.") AND tl_pct_customelement_attribute.published=1";
  706.         return AttributeModel::findByCustomSql($strQuery,array(),$arrOptions);
  707.     }
  708.         
  709.     
  710.     /**
  711.      * Return the class defintion for an attribute by its type name
  712.      * @param string
  713.      * @return string
  714.      */
  715.     public static function getAttributeClassByType($strName)
  716.     {
  717.         return $GLOBALS['PCT_CUSTOMELEMENTS']['ATTRIBUTES'][$strName]['class'];
  718.     }
  719.     
  720.     
  721.     /**
  722.      * Return the system columns as array
  723.      * @return array
  724.      */
  725.     public static function getSystemColumns()
  726.     {
  727.         return array('id','pid','tstamp','sorting');
  728.     }
  729.     
  730.     
  731.     /**
  732.      * Return a unique generic name
  733.      * @param object DataContainer
  734.      * @param string
  735.      * @param integer
  736.      * @return object DataContainer
  737.      */
  738.     public static function generateUuid($objDC, $intLength=15, $strCharSet='1234567890abcdefghijklmnopqrstuvwxyz')
  739.     {
  740.         $objDatabase = \Contao\Database::getInstance();
  741.         
  742.         $strTable = $objDC->table;
  743.         if(isset($objDC->ref_table))
  744.         {
  745.             $strTable = $objDC->ref_table;
  746.         }
  747.         
  748.         $objUuid = $objDatabase->prepare("SELECT id,uuid FROM ".$strTable." WHERE id=?")->limit(1)->execute($objDC->id);
  749.         if($objUuid->numRows > 0 && strlen($objUuid->uuid) > 0)
  750.         {
  751.             return $objDC;
  752.         }
  753.         
  754.         $strUuid = static::generatePassword($intLength,$strCharSet);
  755.         
  756.         $objSiblings = $objDatabase->prepare("SELECT id FROM ".$strTable." WHERE uuid=? AND id!=?")->limit(1)->execute($strUuid,$objDC->id);
  757.         // generate a new uuid this one is taken
  758.         if($objSiblings->numRows > 0)
  759.         {
  760.             return static::generateUuid($objDC,$intLength+1);
  761.         }
  762.         
  763.         return $strUuid;
  764.     }
  765.     
  766.     /**
  767.      * Generate a random string
  768.      * @param integer
  769.      * @return string
  770.      */
  771.     public static function generatePassword($intLength=8,$strCharSet='')
  772.     {
  773.         if(!$strCharSet)
  774.         {
  775.             $strCharSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  776.         }
  777.         
  778.         $max = strlen($strCharSet);
  779.         $rand = rand(0,$max);
  780.         
  781.         $return = '';
  782.         for($i = 0; $i <= $intLength-1; $i++)
  783.         {
  784.             $rand = rand(0,$max);
  785.             $return .= substr($strCharSet, $rand,1);
  786.         }
  787.         
  788.         return $return;
  789.     }
  790.     
  791.         
  792.     /**
  793.      * Get the attribute id in the session registry by the generic name
  794.      * @param string
  795.      * @param integer
  796.      * @param string
  797.      * @return integer
  798.      */
  799.     public static function getAttributeIdFromSession($strName,$intElement=0,$strTable='')
  800.     {
  801.         $objSession = \Contao\System::getContainer()->get('session');
  802.         $arrSession =  $objSession->get('pct_customelements');
  803.         $arrRegistry = $arrSession['registry'];
  804.         
  805.         // use the global as fallback if session fails
  806.         if(!$arrSession['registry'])
  807.         {
  808.             $arrRegistry = $GLOBALS['PCT_CUSTOMELEMENTS_REGISTRY'];
  809.         }
  810.         
  811.         if(!$strTable)
  812.         {
  813.             $strTable = \Contao\Input::get('table');
  814.         }
  815.         
  816.         if($intElement < 1)
  817.         {
  818.             $intElement = \Contao\Input::get('id');
  819.         }
  820.         
  821.         if(empty($arrRegistry[$strTable]))
  822.         {
  823.             return null;
  824.         }
  825.                 
  826.         return $arrRegistry[$strTable][$intElement][$strName]['id'];        
  827.     }
  828. }