1: <?php
  2: /**
  3:  * Cache handlers
  4:  *
  5:  * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
  6:  * @license             GNU GPL 2 (http://www.gnu.org/licenses/gpl-2.0.html)
  7:  * @author              Taiwen Jiang <phppp@users.sourceforge.net>
  8:  * @since               1.00
  9:  * @package             Frameworks
 10:  * @subpackage          art
 11:  */
 12: 
 13: if (!defined('FRAMEWORKS_ART_FUNCTIONS_CACHE')):
 14:     define('FRAMEWORKS_ART_FUNCTIONS_CACHE', true);
 15: 
 16:     /**
 17:      * @param null|array $groups
 18:      *
 19:      * @return string
 20:      */
 21:     function mod_generateCacheId_byGroup($groups = null)
 22:     {
 23:         global $xoopsUser;
 24: 
 25:         if (!empty($groups) && is_array($groups)) {
 26:         } elseif (is_object($xoopsUser)) {
 27:             $groups = $xoopsUser->getGroups();
 28:         }
 29:         if (!empty($groups) && is_array($groups)) {
 30:             sort($groups);
 31:             $contentCacheId = substr(md5(implode(',', $groups) . XOOPS_DB_PASS . XOOPS_DB_NAME), 0, strlen(XOOPS_DB_USER) * 2);
 32:         } else {
 33:             $contentCacheId = XOOPS_GROUP_ANONYMOUS;
 34:         }
 35: 
 36:         return $contentCacheId;
 37:     }
 38: 
 39:     /**
 40:      * @param null $groups
 41:      *
 42:      * @return string
 43:      */
 44:     function mod_generateCacheId($groups = null)
 45:     {
 46:         return mod_generateCacheId_byGroup($groups);
 47:     }
 48: 
 49:     /**
 50:      * @param        $data
 51:      * @param null|string   $name
 52:      * @param null|string   $dirname
 53:      * @param string $root_path
 54:      *
 55:      * @return bool
 56:      */
 57:     function mod_createFile($data, $name = null, $dirname = null, $root_path = XOOPS_CACHE_PATH)
 58:     {
 59:         global $xoopsModule;
 60: 
 61:         $name    = $name ? : (string)time();
 62:         $dirname = $dirname ? : (is_object($xoopsModule) ? $xoopsModule->getVar('dirname', 'n') : 'system');
 63: 
 64:         xoops_load('XoopsCache');
 65:         $key = "{$dirname}_{$name}";
 66: 
 67:         return XoopsCache::write($key, $data);
 68:     }
 69: 
 70:     /**
 71:      * @param      $data
 72:      * @param null $name
 73:      * @param null $dirname
 74:      *
 75:      * @return bool
 76:      */
 77:     function mod_createCacheFile($data, $name = null, $dirname = null)
 78:     {
 79:         return mod_createFile($data, $name, $dirname);
 80:     }
 81: 
 82:     /**
 83:      * @param      $data
 84:      * @param null|string $name
 85:      * @param null $dirname
 86:      * @param null $groups
 87:      *
 88:      * @return bool
 89:      */
 90:     function mod_createCacheFile_byGroup($data, $name = null, $dirname = null, $groups = null)
 91:     {
 92:         $name .= mod_generateCacheId_byGroup();
 93: 
 94:         return mod_createCacheFile($data, $name, $dirname);
 95:     }
 96: 
 97:     /**
 98:      * @param        $name
 99:      * @param null|string   $dirname
100:      * @param string $root_path
101:      *
102:      * @return mixed|null
103:      */
104:     function mod_loadFile($name, $dirname = null, $root_path = XOOPS_CACHE_PATH)
105:     {
106:         global $xoopsModule;
107: 
108:         $data = null;
109: 
110:         if (empty($name)) {
111:             return $data;
112:         }
113:         $dirname = $dirname ? : (is_object($xoopsModule) ? $xoopsModule->getVar('dirname', 'n') : 'system');
114:         xoops_load('XoopsCache');
115:         $key = "{$dirname}_{$name}";
116: 
117:         return XoopsCache::read($key);
118:     }
119: 
120:     /**
121:      * @param      $name
122:      * @param null $dirname
123:      *
124:      * @return mixed|null
125:      */
126:     function mod_loadCacheFile($name, $dirname = null)
127:     {
128:         $data = mod_loadFile($name, $dirname);
129: 
130:         return $data;
131:     }
132: 
133:     /**
134:      * @param      $name
135:      * @param null $dirname
136:      * @param null $groups
137:      *
138:      * @return mixed|null
139:      */
140:     function mod_loadCacheFile_byGroup($name, $dirname = null, $groups = null)
141:     {
142:         $name .= mod_generateCacheId_byGroup();
143:         $data = mod_loadFile($name, $dirname);
144: 
145:         return $data;
146:     }
147: 
148:     /* Shall we use the function of glob for better performance ? */
149: 
150:     /**
151:      * @param string $name
152:      * @param null   $dirname
153:      * @param string $root_path
154:      *
155:      * @return bool
156:      */
157:     function mod_clearFile($name = '', $dirname = null, $root_path = XOOPS_CACHE_PATH)
158:     {
159:         if (empty($dirname)) {
160:             $pattern = $dirname ? "{$dirname}_{$name}.*\.php" : "[^_]+_{$name}.*\.php";
161:             if ($handle = opendir($root_path)) {
162:                 while (false !== ($file = readdir($handle))) {
163:                     if (is_file($root_path . '/' . $file) && preg_match("/{$pattern}$/", $file)) {
164:                         @unlink($root_path . '/' . $file);
165:                     }
166:                 }
167:                 closedir($handle);
168:             }
169:         } else {
170:             $files = (array)glob($root_path . "/*{$dirname}_{$name}*.php");
171:             foreach ($files as $file) {
172:                 @unlink($file);
173:             }
174:         }
175: 
176:         return true;
177:     }
178: 
179:     /**
180:      * @param string $name
181:      * @param null   $dirname
182:      *
183:      * @return bool
184:      */
185:     function mod_clearCacheFile($name = '', $dirname = null)
186:     {
187:         return mod_clearFile($name, $dirname);
188:     }
189: 
190:     /**
191:      * @param string $pattern
192:      *
193:      * @return bool
194:      */
195:     function mod_clearSmartyCache($pattern = '')
196:     {
197:         global $xoopsModule;
198: 
199:         if (empty($pattern)) {
200:             $dirname = (is_object($xoopsModule) ? $xoopsModule->getVar('dirname', 'n') : 'system');
201:             $pattern = "/(^{$dirname}\^.*\.html$|blk_{$dirname}_.*[^\.]*\.html$)/";
202:         }
203:         if ($handle = opendir(XOOPS_CACHE_PATH)) {
204:             while (false !== ($file = readdir($handle))) {
205:                 if (is_file(XOOPS_CACHE_PATH . '/' . $file) && preg_match($pattern, $file)) {
206:                     @unlink(XOOPS_CACHE_PATH . '/' . $file);
207:                 }
208:             }
209:             closedir($handle);
210:         }
211: 
212:         return true;
213:     }
214: 
215: endif;
216: