1: <?php
  2: /**
  3:  * XOOPS Kernel Class
  4:  *
  5:  * You may not change or alter any portion of this comment or credits
  6:  * of supporting developers from this source code or any supporting source code
  7:  * which is considered copyrighted (c) material of the original comment or credit authors.
  8:  * This program is distributed in the hope that it will be useful,
  9:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 11:  *
 12:  * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
 13:  * @license             GNU GPL 2 (http://www.gnu.org/licenses/gpl-2.0.html)
 14:  * @package             kernel
 15:  * @since               2.0.0
 16:  * @author              Kazumi Ono (AKA onokazu) http://www.myweb.ne.jp/, http://jp.xoops.org/
 17:  */
 18: defined('XOOPS_ROOT_PATH') || exit('Restricted access');
 19: 
 20: require_once $GLOBALS['xoops']->path('kernel/configoption.php');
 21: require_once $GLOBALS['xoops']->path('kernel/configitem.php');
 22: 
 23: /**
 24:  * XOOPS configuration handling class.
 25:  * This class acts as an interface for handling general configurations of XOOPS
 26:  * and its modules.
 27:  *
 28:  * @author  Kazumi Ono <webmaster@myweb.ne.jp>
 29:  * @todo    Tests that need to be made:
 30:  *          - error handling
 31:  * @access  public
 32:  */
 33: class XoopsConfigHandler
 34: {
 35:     /**
 36:      * holds reference to config item handler(DAO) class
 37:      *
 38:      * @var object
 39:      * @access    private
 40:      */
 41:     public $_cHandler;
 42: 
 43:     /**
 44:      * holds reference to config option handler(DAO) class
 45:      *
 46:      * @var object
 47:      * @access    private
 48:      */
 49:     public $_oHandler;
 50: 
 51:     /**
 52:      * holds an array of cached references to config value arrays,
 53:      *  indexed on module id and category id
 54:      *
 55:      * @var array
 56:      * @access  private
 57:      */
 58:     public $_cachedConfigs = array();
 59: 
 60:     /**
 61:      * Constructor
 62:      *
 63:      * @param XoopsDatabase $db reference to database object
 64:      */
 65:     public function __construct(XoopsDatabase $db)
 66:     {
 67:         $this->_cHandler = new XoopsConfigItemHandler($db);
 68:         $this->_oHandler = new XoopsConfigOptionHandler($db);
 69:     }
 70: 
 71:     /**
 72:      * Create a config
 73:      *
 74:      * @see     XoopsConfigItem
 75:      * @return XoopsConfigItem reference to the new {@link XoopsConfigItem}
 76:      */
 77:     public function createConfig()
 78:     {
 79:         $instance = $this->_cHandler->create();
 80: 
 81:         return $instance;
 82:     }
 83: 
 84:     /**
 85:      * Get a config
 86:      *
 87:      * @param  int  $id          ID of the config
 88:      * @param  bool $withoptions load the config's options now?
 89:      * @return object reference to the {@link XoopsConfig}
 90:      */
 91:     public function getConfig($id, $withoptions = false)
 92:     {
 93:         $config = $this->_cHandler->get($id);
 94:         if ($withoptions === true) {
 95:             $config->setConfOptions($this->getConfigOptions(new Criteria('conf_id', $id)));
 96:         }
 97: 
 98:         return $config;
 99:     }
100: 
101:     /**
102:      * insert a new config in the database
103:      *
104:      * @param XoopsConfigItem $config reference to the {@link XoopsConfigItem}
105:      *
106:      * @return bool
107:      */
108:     public function insertConfig(XoopsConfigItem $config)
109:     {
110:         if (!$this->_cHandler->insert($config)) {
111:             return false;
112:         }
113:         $options =& $config->getConfOptions();
114:         $count   = count($options);
115:         $conf_id = $config->getVar('conf_id');
116:         for ($i = 0; $i < $count; ++$i) {
117:             $options[$i]->setVar('conf_id', $conf_id);
118:             if (!$this->_oHandler->insert($options[$i])) {
119:                 foreach ($options[$i]->getErrors() as $msg) {
120:                     $config->setErrors($msg);
121:                 }
122:             }
123:         }
124:         if (!empty($this->_cachedConfigs[$config->getVar('conf_modid')][$config->getVar('conf_catid')])) {
125:             unset($this->_cachedConfigs[$config->getVar('conf_modid')][$config->getVar('conf_catid')]);
126:         }
127: 
128:         return true;
129:     }
130: 
131:     /**
132:      * Delete a config from the database
133:      *
134:      * @param XoopsConfigItem $config reference to a {@link XoopsConfigItem}
135:      *
136:      * @return bool
137:      */
138:     public function deleteConfig(XoopsConfigItem $config)
139:     {
140:         if (!$this->_cHandler->delete($config)) {
141:             return false;
142:         }
143:         $options = &$config->getConfOptions();
144:         $count   = count($options);
145:         if ($count == 0) {
146:             $options = $this->getConfigOptions(new Criteria('conf_id', $config->getVar('conf_id')));
147:             $count   = count($options);
148:         }
149:         if (is_array($options) && $count > 0) {
150:             for ($i = 0; $i < $count; ++$i) {
151:                 $this->_oHandler->delete($options[$i]);
152:             }
153:         }
154:         if (!empty($this->_cachedConfigs[$config->getVar('conf_modid')][$config->getVar('conf_catid')])) {
155:             unset($this->_cachedConfigs[$config->getVar('conf_modid')][$config->getVar('conf_catid')]);
156:         }
157: 
158:         return true;
159:     }
160: 
161:     /**
162:      * get one or more Configs
163:      *
164:      * @param CriteriaElement $criteria     {@link CriteriaElement}
165:      * @param bool            $id_as_key    Use the configs' ID as keys?
166:      * @param bool            $with_options get the options now?
167:      *
168:      * @return array Array of {@link XoopsConfigItem} objects
169:      */
170:     public function getConfigs(CriteriaElement $criteria = null, $id_as_key = false, $with_options = false)
171:     {
172:         return $this->_cHandler->getObjects($criteria, $id_as_key);
173:     }
174: 
175:     /**
176:      * Count some configs
177:      *
178:      * @param CriteriaElement $criteria {@link CriteriaElement}
179:      *
180:      * @return int
181:      */
182:     public function getConfigCount(CriteriaElement $criteria = null)
183:     {
184:         return $this->_cHandler->getCount($criteria);
185:     }
186: 
187:     /**
188:      * Get configs from a certain category
189:      *
190:      * @param int $category ID of a category
191:      * @param int $module   ID of a module
192:      *
193:      * @return array array of {@link XoopsConfig}s
194:      */
195:     public function &getConfigsByCat($category, $module = 0)
196:     {
197:         static $_cachedConfigs;
198:         if (!empty($_cachedConfigs[$module][$category])) {
199:             return $_cachedConfigs[$module][$category];
200:         } else {
201:             $ret      = array();
202:             $criteria = new CriteriaCompo(new Criteria('conf_modid', (int)$module));
203:             if (!empty($category)) {
204:                 $criteria->add(new Criteria('conf_catid', (int)$category));
205:             }
206:             $configs = $this->getConfigs($criteria, true);
207:             if (is_array($configs)) {
208:                 foreach (array_keys($configs) as $i) {
209:                     $ret[$configs[$i]->getVar('conf_name')] = $configs[$i]->getConfValueForOutput();
210:                 }
211:             }
212:             $_cachedConfigs[$module][$category] = $ret;
213: 
214:             return $_cachedConfigs[$module][$category];
215:         }
216:     }
217: 
218:     /**
219:      * Make a new {@link XoopsConfigOption}
220:      *
221:      * @return XoopsConfigOption {@link XoopsConfigOption}
222:      */
223:     public function createConfigOption()
224:     {
225:         $inst = $this->_oHandler->create();
226: 
227:         return $inst;
228:     }
229: 
230:     /**
231:      * Get a {@link XoopsConfigOption}
232:      *
233:      * @param int $id ID of the config option
234:      *
235:      * @return XoopsConfigOption {@link XoopsConfigOption}
236:      */
237:     public function getConfigOption($id)
238:     {
239:         $inst = $this->_oHandler->get($id);
240: 
241:         return $inst;
242:     }
243: 
244:     /**
245:      * Get one or more {@link XoopsConfigOption}s
246:      *
247:      * @param CriteriaElement $criteria  {@link CriteriaElement}
248:      * @param bool            $id_as_key Use IDs as keys in the array?
249:      *
250:      * @return array Array of {@link XoopsConfigOption}s
251:      */
252:     public function getConfigOptions(CriteriaElement $criteria = null, $id_as_key = false)
253:     {
254:         return $this->_oHandler->getObjects($criteria, $id_as_key);
255:     }
256: 
257:     /**
258:      * Count some {@link XoopsConfigOption}s
259:      *
260:      * @param CriteriaElement $criteria {@link CriteriaElement}
261:      *
262:      * @return int Count of {@link XoopsConfigOption}s matching $criteria
263:      */
264:     public function getConfigOptionsCount(CriteriaElement $criteria = null)
265:     {
266:         return $this->_oHandler->getCount($criteria);
267:     }
268: 
269:     /**
270:      * Get a list of configs
271:      *
272:      * @param int $conf_modid ID of the modules
273:      * @param int $conf_catid ID of the category
274:      *
275:      * @return array Associative array of name=>value pairs.
276:      */
277:     public function getConfigList($conf_modid, $conf_catid = 0)
278:     {
279:         if (!empty($this->_cachedConfigs[$conf_modid][$conf_catid])) {
280:             return $this->_cachedConfigs[$conf_modid][$conf_catid];
281:         } else {
282:             $criteria = new CriteriaCompo(new Criteria('conf_modid', $conf_modid));
283:             if (empty($conf_catid)) {
284:                 $criteria->add(new Criteria('conf_catid', $conf_catid));
285:             }
286:             $configs   = $this->_cHandler->getObjects($criteria);
287:             $confcount = count($configs);
288:             $ret       = array();
289:             for ($i = 0; $i < $confcount; ++$i) {
290:                 $ret[$configs[$i]->getVar('conf_name')] = $configs[$i]->getConfValueForOutput();
291:             }
292:             $this->_cachedConfigs[$conf_modid][$conf_catid] = &$ret;
293: 
294:             return $ret;
295:         }
296:     }
297: 
298:     /**#@+
299:      * @deprecated
300:      * @param $criteria
301:      * @return bool
302:      */
303:     public function deleteConfigOption(&$criteria)
304:     {
305:         trigger_error(__CLASS__ . '::' . __FUNCTION__ . ' is deprecated', E_USER_WARNING);
306: 
307:         return false;
308:     }
309:     /**#@-*/
310: }
311: