system/modules/pct_customelements/PCT/CustomElements/Core/Cache.php line 332

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 2015, Premium Contao Webworks, Premium Contao Themes
  9.  * @author        Tim Gatzky <info@tim-gatzky.de>
  10.  * @package        pct_customelements
  11.  * @link        http://contao.org
  12.  */
  13.  
  14. /**
  15.  * Namespace
  16.  */
  17. namespace PCT\CustomElements\Core;
  19. /**
  20.  * Imports
  21.  */
  22. use PCT\CustomElements\Core\CustomElement as CustomElement;
  23. use PCT\CustomElements\Core\Attribute as Attribute;
  24. use PCT\CustomElements\Core\Group as Group;
  26. /**
  27.  * Cache
  28.  */
  29. class Cache
  30. {
  31.     /**
  32.      * Initialize the global cache array
  33.      */
  34.     public function __construct()
  35.     {
  36.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']))
  37.         {
  38.             $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'] = array();
  39.         }
  41.         foreach(array('CUSTOMELEMENT','CONTENTELEMENTSET','PLUGINS','CUSTOMCATALOG','GROUP','ATTRIBUTE','ACTIVE_CUSTOMCATALOGS') as $k )
  42.         {
  43.             if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'][$k]) )
  44.             {
  45.                 $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'][$k] = array();
  46.             }
  47.         }
  48.     }
  49.     
  50.     
  51.     /**
  52.      * Add any data
  53.      * @param string
  54.      * @param mixed
  55.      */
  56.     public static function add($strKey,$varInput)
  57.     {
  58.         switch($strKey)
  59.         {
  60.             case 'customcatalog':
  61.                 static::addCustomCatalog($strKey,$varInput);
  62.                 break;
  63.             case 'attribute':
  64.                 static::addAttribute($strKey,$varInput);
  65.                 break;
  66.             default:
  67.                 $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'][$strKey] = $varInput;
  68.                 break;
  69.         }
  70.     }
  71.     
  72.     
  73.     /**
  74.      * Return data by key
  75.      * @param string
  76.      * @param mixed
  77.      */
  78.     public static function get($strKey)
  79.     {
  80.         if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'][$strKey]) )
  81.         {
  82.             return null;
  83.         }
  84.         
  85.         if($GLOBALS['PCT_CUSTOMCATALOG']['SETTINGS']['bypassCache'])
  86.         {
  87.             return null;
  88.         }
  89.         
  90.         switch($strKey)
  91.         {
  92.             default:
  93.                 return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'][$strKey];
  94.                 break;
  95.         }
  96.         
  97.         return null;
  98.     }
  100.     
  101.     
  102.     /**
  103.      * Set the whole cache by an array
  104.      * @param array
  105.      */
  106.     public static function setData($arrData)
  107.     {
  108.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'] = $arrData;
  109.     }
  110.     
  111.     
  112.     /**
  113.      * Return the cached array data
  114.      * @return array
  115.      */
  116.     public static function getData()
  117.     {
  118.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']))
  119.         {
  120.             $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'] = array();
  121.         }
  123.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE'];
  124.     }
  125.     
  126.     
  127.     /**
  128.      * Add an attribute object to the cache by its alias or ID or any other key
  129.      * @param object    CE/CC Attribute object
  130.      * @param mixed        String identifiyer
  131.      */
  132.     public static function addAttribute($varKey,$objInput)
  133.     {
  134.         if($objInput === null)
  135.         {
  136.             return;
  137.         }
  138.         
  139.         $objSet = null;
  140.         
  141.         // create a real object if a database result has been added
  142.         if(strlen(strpos(get_class($objInput), 'Database')) > 0)
  143.         {
  144.             $objSet = new Attribute($objInput->row());
  145.             $objSet = $objSet->generate();
  146.             if(!$objSet)
  147.             {
  148.                 return;
  149.             }
  150.             $objSet->db_result = $objInput;
  151.         }
  152.         else
  153.         {
  154.             $objSet = $objInput;
  155.         }
  156.         
  157.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['ATTRIBUTE'][$varKey] = $objSet;
  158.     }
  159.     
  160.     
  161.     /**
  162.      * Return an object by its identifiyer (e.g. alias or id or any other identifiyer used)
  163.      * @param mixed
  164.      * @return object     CE/CC Attribute object
  165.      */
  166.     public static function getAttribute($varKey)
  167.     {
  168.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['ATTRIBUTE'][$varKey]))
  169.         {
  170.             return null;
  171.         }
  172.         return clone($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['ATTRIBUTE'][$varKey]);
  173.     }
  174.     
  175.     
  176.     /**
  177.      * Add an group object to the cache by its alias or ID or any other key
  178.      * @param object    CE/CC Group object
  179.      * @param mixed        String identifiyer
  180.      */
  181.     public static function addGroup($varKey,$objInput)
  182.     {
  183.         $objSet = null;
  184.         
  185.         // create a real object if a database result has been added
  186.         if(strlen(strpos(get_class($objInput), 'Database')) > 0)
  187.         {
  188.             $objSet = new Group($objInput->row());
  189.             $objSet = $objSet->generate();
  190.             if(!$objSet)
  191.             {
  192.                 return;
  193.             }
  194.             $objSet->db_result = $objInput;
  195.         }
  196.         else
  197.         {
  198.             $objSet = $objInput;
  199.         }
  200.         
  201.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUP'][$varKey] = $objSet;
  202.     }
  203.     
  204.     
  205.     /**
  206.      * Return an object by its identifiyer (e.g. alias or id or any other identifiyer used)
  207.      * @param mixed
  208.      * @return object     CE/CC Group object
  209.      */
  210.     public static function getGroup($varKey)
  211.     {
  212.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUP'][$varKey]) || empty($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUP'][$varKey]) )
  213.         {
  214.             return null;
  215.         }
  216.         return clone($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUP'][$varKey]);
  217.     }
  218.     
  219.     
  220.     /**
  221.      * Add an array of groups by an identifiyer
  222.      * @param array|object
  223.      * @return object     array
  224.      */
  225.     public static function addGroupsByPid($varKey,$arrInput)
  226.     {
  227.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUPS'][$varKey] = $arrInput;
  228.     }
  230.         
  231.     /**
  232.      * Return a groups array by its identifiyer
  233.      * @param mixed
  234.      * @return array
  235.      */
  236.     public static function getGroupsByPid($varKey)
  237.     {
  238.         if(!$GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUPS'][$varKey])
  239.         {
  240.             return array();
  241.         }
  242.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['GROUPS'][$varKey];
  243.     }
  244.     
  245.     
  246.     /**
  247.      * Add a customelement object to the cache
  248.      * @param string
  249.      * @param object    CustomElement instance
  250.      */
  251.     public static function addCustomElement($varKey,$objInput)
  252.     {
  253.         $objSet = null;
  254.         
  255.         // create a real object if a database result has been added
  256.         if(strlen(strpos(get_class($objInput), 'Database')) > 0)
  257.         {
  258.             $objSet = new CustomElement($objInput->row());
  259.             if(!$objSet)
  260.             {
  261.                 return;
  262.             }
  263.             $objSet->db_result = $objInput;
  264.         }
  265.         else
  266.         {
  267.             $objSet = $objInput;
  268.         }
  269.         
  270.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CUSTOMELEMENT'][$varKey] = $objSet;
  271.     }
  272.     
  273.     
  274.     /**
  275.      * Return a customcatalog object from the cache
  276.      * @param mixed
  277.      * @return object
  278.      */
  279.     public static function getCustomElement($varKey)
  280.     {
  281.         if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CUSTOMELEMENT'][$varKey]) )
  282.         {
  283.             return null;
  284.         }
  285.         return clone($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CUSTOMELEMENT'][$varKey]);
  286.     }
  287.     
  288.     
  289.     /**
  290.      * Add an active plugin to the cache
  291.      * @param string
  292.      */
  293.     public static function addPlugin($varKey)
  294.     {
  295.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['PLUGINS'][$varKey] = $varKey;
  296.     }
  297.     
  298.     
  299.     /**
  300.      * Return active plugins from the cache
  301.      * @param string
  302.      * @return array
  303.      */
  304.     public static function getPlugins()
  305.     {
  306.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['PLUGINS']))
  307.         {
  308.             return null;
  309.         }
  310.         
  311.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['PLUGINS'];
  312.     }
  313.     
  314.     
  315.     /**
  316.      * Add a stack of plugins as array
  317.      * @param array
  318.      */
  319.     public static function addPlugins($arrData)
  320.     {
  321.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['PLUGINS'] = $arrData;
  322.     }
  323.     
  324.     
  325.     /**
  326.      * Add wizard data to cache
  327.      * @param integer
  328.      * @param string
  329.      * @param integer
  330.      * @param array||string
  331.      */
  332.     public static function addWizard($intPid,$strSource,$intGenericAttribut=0,$arrData)
  333.     {
  334.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['WIZARD'][$strSource][$intPid][$intGenericAttribut] = $arrData;
  335.     }
  336.     
  337.     
  338.     /**
  339.      * Return active plugins from the cache
  340.      * @param string
  341.      */
  342.     public static function getWizard($intPid,$strSource,$intGenericAttribute=0)
  343.     {
  344.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['WIZARD'][$strSource][$intPid][$intGenericAttribute]))
  345.         {
  346.             return array();
  347.         }
  348.         
  349.         return \Contao\StringUtil::deserialize($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['WIZARD'][$strSource][$intPid][$intGenericAttribute]);
  350.     }
  351.     
  352.     
  353.     /**
  354.      * Add a content element set data array to the cache
  355.      * @param string    Key name of the set file
  356.      * @param array        Data array
  357.      */
  358.     public static function addContentElementSet($strKey,$arrData)
  359.     {
  360.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'][$strKey] = $arrData;
  361.     }
  362.     
  363.     
  364.     /**
  365.      * Add a content element set data array to the cache
  366.      * @return array
  367.      */
  368.     public static function getContentElementSet($strKey)
  369.     {
  370.         if(!isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'][$strKey]))
  371.         {
  372.             return array();
  373.         }
  374.         
  375.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'][$strKey];
  376.     }
  377.     
  378.     
  379.     /**
  380.      * Add a whole stack of content element set data 
  381.      * @param array
  382.      */
  383.     public static function addContentElementSets($arrInput)
  384.     {
  385.         if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET']) )
  386.         {
  387.             $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'] = null;
  388.         }
  389.         $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'] = $arrInput;
  390.     }
  391.     
  392.     
  393.     /**
  394.      * Return all content element sets
  395.      * @return array||null
  396.      */
  397.     public static function getContentElementSets()
  398.     {
  399.         if( !isset($GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET']) )
  400.         {
  401.             return null;
  402.         }
  403.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CONTENTELEMENTSET'];
  404.     }
  405.     
  406.     
  407.     /**
  408.      * @shortcut to getCustomElement
  409.      */
  410.     public static function findCustomElementByAlias($strKey)
  411.     {
  412.         return static::getCustomElement($strKey);
  413.     }
  414.     
  415.     
  416.     /**
  417.      * @shortcut to getCustomElement
  418.      */
  419.     public static function findCustomElementById($intKey)
  420.     {
  421.         return static::getCustomCatalog($intKey);
  422.     }
  423.     
  424.     
  425.     /**
  426.      * Return an customelement object by an attribute object
  427.      * @param object    Attribute
  428.      * @return object
  429.      */
  430.     public static function findCustomElementByGroup($varGroup)
  431.     {
  432.         if(!$GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CUSTOMELEMENT']['_byGroup_'][$varGroup])
  433.         {
  434.             return null;
  435.         }
  436.         return $GLOBALS['PCT_CUSTOMELEMENTS']['CACHE']['CUSTOMELEMENT']['_byGroup_'][$varGroup];
  437.     }
  438. }