Source for file jZone.class.php

Documentation is available at jZone.class.php

1. <?php
2. /**
3. * @package    jelix
4. * @subpackage utils
5. * @author     Gérald Croes, Laurent Jouanneau
6. * @contributor Laurent Jouanneau, Laurent Raufaste, Pulsation
7. * @copyright  2001-2005 CopixTeam, 2005-2012 Laurent Jouanneau, 2008 Laurent Raufaste, 2008 Pulsation
8. *
9. *  This class was get originally from the Copix project (CopixZone, Copix 2.3dev20050901, http://www.copix.org)
10. *  Some lines of code are copyrighted 2001-2005 CopixTeam (LGPL licence).
11. *  Initial authors of this Copix classes are Gerald Croes and Laurent Jouanneau,
12. *  and this class was adapted/improved for Jelix by Laurent Jouanneau
13. *
14. * @link        http://www.jelix.org
15. * @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
16. */
17.  
18. /**
19.  * jZone is a representation of a zone in an response content, in a html page.
20.  * A user zone should inherits from jZone. jZone provide a cache mecanism.
21.  * @package    jelix
22.  * @subpackage utils
23.  */
24. class jZone {
25.     /**
26.     * If we're using cache on this zone
27.     * You should override it in your class if you want activate the cache
28.     * @var boolean 
29.     */
30.     protected $_useCache = false;
31.  
32.     /**
33.      * cache timeout (seconds).
34.      * set to 0 if you want to delete cache manually.
35.      * @var integer 
36.      */
37.     protected $_cacheTimeout = 0;
38.  
39.     /**
40.     * list of zone parameters
41.     * @var array 
42.     */
43.     protected $_params;
44.  
45.     /**
46.      * template selector
47.      * If you want to use a template for your zone, set its name in this property
48.      * in your zone, and override _prepareTpl. Else, keep it to empty string, and
49.      * override _createContent
50.      * @var string 
51.      */
52.     protected $_tplname='';
53.  
54.     /**
55.      * says the type of the output of the template, in the case of the result
56.      * of the zone is not used in a response in the same output type.
57.      * For example, the output type of a ajax response is text, but the template
58.      * can contains html, so the template should be treated as html content,
59.      * so you should put 'html' here.
60.      * If empty, the output type will be the output type of the current response.
61.      * @var string 
62.      * @see jTpl::fetch
63.      */
64.     protected $_tplOutputType='';
65.  
66.     /**
67.      * the jtpl object created automatically by jZone if you set up _tplname
68.      * you can use it in _prepareTpl
69.      * @var jTpl 
70.      */
71.     protected $_tpl=null;
72.  
73.     /**
74.      * When the cache system is activated, says if the cache should be generated or not
75.      * you set it to false in _createContent or _prepareTpl, in specific case.
76.      * @var boolean 
77.      */
78.     protected $_cancelCache=false;
79.  
80.     /**
81.      * constructor.
82.      */
83.     function __construct($params=array()){
84.         $this->_params = $params;
85.     }
86.  
87.     /**
88.     * get the content of a zone
89.     * @param string $name zone selector
90.     * @param array $params parameters for the zone
91.     * @return string the generated content of the zone
92.     * @since 1.0b1
93.     */
94.     public static function get ($name, $params=array ()){
95.         return self::_callZone($name, 'getContent', $params);
96.     }
97.  
98.     /**
99.     * clear a specific cache of a zone
100.     * @param string $name zone selector
101.     * @param array $params parameters for the zone
102.     * @since 1.0b1
103.     */
104.     public static function clear ($name, $params=array ()){
105.         return self::_callZone($name, 'clearCache', $params);
106.     }
107.  
108.     /**
109.     * clear all zone cache or all cache of a specific zone
110.     * @param string $name zone selector
111.     * @since 1.0b1
112.     */
113.     public static function clearAll($name=''){
114.         $dir = jApp::tempPath('zonecache/');
115.         if(!file_exists($dir)) return;
116.  
117.         if($name !=''){
118.             $sel = new jSelectorZone($name);
119.             $fic = '~'.$sel->module.'~'.strtolower($sel->resource).'zone~';
120.         }else{
121.             $fic = '~';
122.         }
123.  
124.         if ($dh = opendir($dir)) {
125.            while (($file = readdir($dh)) !== false) {
126.                if(strpos($file, $fic) === 0){
127.                    unlink($dir.$file);
128.                }
129.            }
130.            closedir($dh);
131.        }
132.     }
133.  
134.     /**
135.     * gets the value of a parameter, if defined. Returns the default value instead.
136.     * @param string $paramName the parameter name
137.     * @param mixed $defaultValue the parameter default value
138.     * @return mixed the param value
139.     */
140.     public function param ($paramName, $defaultValue=null){
141.         return array_key_exists ($paramName, $this->_params) ? $this->_params[$paramName] : $defaultValue;
142.     }
143.  
144.     /**
145.     * get the zone content
146.     * Return the cache content if it is activated and if it's exists, or call _createContent
147.     * @return string  zone content
148.     */
149.     public function getContent (){
150.  
151.         if ($this->_useCache && !jApp::config()->zones['disableCache']){
152.             $cacheFiles = $this->_getCacheFiles();
153.             $f = $cacheFiles['content'];
154.             if(file_exists($f)){
155.                 if($this->_cacheTimeout > 0){
156.                     clearstatcache(false, $f);
157.                     if(time() - filemtime($f) > $this->_cacheTimeout){
158.                         // timeout : regenerate the cache
159.                         unlink($f);
160.                         $this->_cancelCache=false;
161.                         $response = jApp::coord()->response;
162.                         $sniffer = new jMethodSniffer( $response, '$resp', array('getType', 'getFormatType'), true );
163.                         jApp::coord()->response = $sniffer;
164.                         $content=$this->_createContent();
165.                         jApp::coord()->response = $response;
166.                         if(!$this->_cancelCache){
167.                             jFile::write($f,$content);
168.                             jFile::write($cacheFiles['meta'], (string)$sniffer);
169.                         }
170.                         return $content;
171.                     }
172.                 }
173.                 //fetch metas from cache :
174.                 if( file_exists($cacheFiles['meta']) ) {
175.                     if( filesize($cacheFiles['meta']) > 0 ) {
176.                         //create an anonymous function and then unset it. if jZone cache is cleared within 2 calls in a single
177.                         //request, this should still work fine
178.                         $metaFunct = create_function('$resp', file_get_contents($cacheFiles['meta']));
179.                         $metaFunct( jApp::coord()->response );
180.                         unset( $metaFunct );
181.                     }
182.                 } else {
183.                     //the cache does not exist yet for this response type. We have to generate it !
184.                     $response = jApp::coord()->response;
185.                     $sniffer = new jMethodSniffer( $response, '$resp', array('getType', 'getFormatType'), true );
186.                     jApp::coord()->response = $sniffer;
187.                     $this->_createContent();
188.                     jApp::coord()->response = $response;
189.                     if(!$this->_cancelCache){
190.                         jFile::write($cacheFiles['meta'], (string)$sniffer);
191.                     }
192.                 }
193.                 //and now fetch content from cache :
194.                 $content = file_get_contents($f);
195.             }else{
196.                 $this->_cancelCache=false;
197.                 $response = jApp::coord()->response;
198.                 $sniffer = new jMethodSniffer( $response, '$resp', array('getType', 'getFormatType'), true );
199.                 jApp::coord()->response = $sniffer;
200.                 $content=$this->_createContent();
201.                 jApp::coord()->response = $response;
202.                 if(!$this->_cancelCache){
203.                     jFile::write($f,$content);
204.                     jFile::write($cacheFiles['meta'], (string)$sniffer);
205.                 }
206.             }
207.         }else{
208.             $content=$this->_createContent();
209.         }
210.         return $content;
211.     }
212.  
213.     /**
214.     * Delete the cache of the current zone
215.     */
216.     public function clearCache (){
217.         if ($this->_useCache){
218.             foreach( $this->_getCacheFiles(false) as $f ) {
219.                 if(file_exists($f)){
220.                     unlink($f);
221.                 }
222.             }
223.         }
224.     }
225.  
226.  
227.     /**
228.     * create the content of the zone
229.     * by default, it uses a template, and so prepare a jtpl object to use in _prepareTpl.
230.     * zone parameters are automatically assigned in the template
231.     * If you don't want a template, override it in your class
232.     * @return string generated content
233.     */
234.     protected function _createContent (){
235.         $this->_tpl = new jTpl();
236.         $this->_tpl->assign($this->_params);
237.         $this->_prepareTpl();
238.         if($this->_tplname == '') return '';
239.         return $this->_tpl->fetch($this->_tplname, $this->_tplOutputType);
240.     }
241.  
242.     /**
243.      * override this method if you want do additionnal thing on the template object
244.      * Example : do access to a dao object.. Note : the template object
245.      * is in the _tpl property
246.      */
247.     protected function _prepareTpl(){
248.  
249.     }
250.  
251.     /**
252.     * create the cache filename
253.     * @return string the filename
254.     */
255.     private function _getCacheFiles($forCurrentResponse=true){
256.         $module = jApp::getCurrentModule ();
257.         $ar = $this->_params;
258.         ksort($ar);
259.         $id=md5(serialize($ar));
260.         $cacheFiles = array( 'content' => jApp::tempPath('zonecache/~'.$module.'~'.strtolower(get_class($this)).'~'.$id.'.php') );
261.         if( $forCurrentResponse ) {
262.             //make distinct a cache files for metas according to response type as meta handling is often different for different responses
263.             $respType = jApp::coord()->response->getType();
264.             $cacheFiles['meta'] = jApp::tempPath('zonecache/~'.$module.'~'.strtolower(get_class($this)).'~meta~'.$respType.'~'.$id.'.php');
265.         } else {
266.             foreach( jApp::config()->responses as $respType ) {
267.                 //list all response types
268.                 if( substr($respType, -5) != '.path' ) {
269.                     $cacheFiles['meta.'.$respType] = jApp::tempPath('zonecache/~'.$module.'~'.strtolower(get_class($this)).'~meta~'.$respType.'~'.$id.'.php');
270.                 }
271.             }
272.         }
273.         return $cacheFiles;
274.     }
275.  
276.    /**
277.     * instancy a zone object, and call one of its methods
278.     * @param string $name zone selector
279.     * @param string $method method name
280.     * @param array  $params arguments for the method
281.     * @return mixed the result returned by the method
282.     */
283.     private static function  _callZone($name,$method, &$params){
284.  
285.         $sel = new jSelectorZone($name);
286.         jApp::pushCurrentModule ($sel->module);
287.  
288.         $fileName = $sel->getPath();
289.         require_once($fileName);
290.         $className = $sel->resource.'Zone';
291.         $zone = new $className ($params);
292.         $toReturn = $zone->$method ();
293.  
294.         jApp::popCurrentModule ();
295.         return $toReturn;
296.     }
297. }

Documentation generated on Wed, 04 Jan 2017 22:57:25 +0100 by phpDocumentor 1.4.3