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       XOOPS Project (http://xoops.org)
 13:  * @license         GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 14:  * @package         kernel
 15:  * @since           2.0.0
 16:  * @version         $Id$
 17:  */
 18: 
 19: namespace Xoops\Core\Kernel\Handlers;
 20: 
 21: use Xoops\Core\Database\Connection;
 22: use Xoops\Core\Kernel\Criteria;
 23: use Xoops\Core\Kernel\CriteriaElement;
 24: use Xoops\Core\Kernel\XoopsPersistableObjectHandler;
 25: 
 26: /**
 27:  * XOOPS module handler class.
 28:  *
 29:  * This class is responsible for providing data access mechanisms to the data source
 30:  * of XOOPS module class objects.
 31:  *
 32:  * @category  Xoops\Core\Kernel\XoopsModuleHandler
 33:  * @package   Xoops\Core\Kernel
 34:  * @author    Kazumi Ono <onokazu@xoops.org>
 35:  * @author    Taiwen Jiang <phppp@users.sourceforge.net>
 36:  * @copyright 2000-2015 XOOPS Project (http://xoops.org)
 37:  * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 38:  * @link      http://xoops.org
 39:  */
 40: class XoopsModuleHandler extends XoopsPersistableObjectHandler
 41: {
 42:     /**
 43:      * holds an array of cached module references, indexed by module id
 44:      *
 45:      * @var array
 46:      * @access private
 47:      */
 48:     private $cachedModulesByMid = array();
 49: 
 50:     /**
 51:      * holds an array of cached module references, indexed by module dirname
 52:      *
 53:      * @var array
 54:      * @access private
 55:      */
 56:     private $cachedModulesByDirname = array();
 57: 
 58:     /**
 59:      * Constructor
 60:      *
 61:      * @param Connection|null $db database
 62:      */
 63:     public function __construct(Connection $db = null)
 64:     {
 65:         parent::__construct($db, 'system_module', '\Xoops\Core\Kernel\Handlers\XoopsModule', 'mid', 'dirname');
 66:     }
 67: 
 68:     /**
 69:      * Load a module from the database
 70:      *
 71:      * @param int $id ID of the module
 72:      *
 73:      * @return XoopsModule|bool on fail
 74:      */
 75:     public function getById($id = null)
 76:     {
 77:         $id = (int)($id);
 78:         if ($id > 0) {
 79:             if (!empty($this->cachedModulesByMid[$id])) {
 80:                 return $this->cachedModulesByMid[$id];
 81:             } else {
 82:                 $module = parent::get($id);
 83:                 if (!is_object($module)) {
 84:                     return false;
 85:                 }
 86:                 $this->cachedModulesByMid[$id] = $module;
 87:                 $this->cachedModulesByDirname[$module->getVar('dirname')] = $module;
 88:                 return $module;
 89:             }
 90:         }
 91:         return false;
 92:     }
 93: 
 94:     /**
 95:      * Load a module by its dirname
 96:      *
 97:      * @param string $dirname module directory name
 98:      *
 99:      * @return XoopsModule|bool FALSE on fail
100:      */
101:     public function getByDirname($dirname)
102:     {
103:         $dirname = basename(trim($dirname));
104: 
105:         if (!empty($this->cachedModulesByDirname[$dirname])) {
106:             return $this->cachedModulesByDirname[$dirname];
107:         } else {
108:             $criteria = new Criteria('dirname', $dirname);
109:             $modules = $this->getObjectsArray($criteria);
110:             if (count($modules) == 1 && is_object($modules[0])) {
111:                 $module = $modules[0];
112:             } else {
113:                 return false;
114:             }
115:             /* @var $module XoopsModule */
116:             $this->cachedModulesByDirname[$dirname] = $module;
117:             $this->cachedModulesByMid[$module->getVar('mid')] = $module;
118:             return $module;
119:         }
120:     }
121: 
122:     /**
123:      * Write a module to the database
124:      *
125:      * @param XoopsModule $module module to insert
126:      *
127:      * @return bool
128:      */
129:     public function insertModule(XoopsModule $module)
130:     {
131:         if (!parent::insert($module)) {
132:             return false;
133:         }
134: 
135:         $dirname = $module->getVar('dirname');
136:         $mid = $module->getVar('mid');
137: 
138:         if (!empty($this->cachedModulesByDirname[$dirname])) {
139:             unset($this->cachedModulesByDirname[$dirname]);
140:         }
141:         if (!empty($this->cachedModulesByMid[$mid])) {
142:             unset($this->cachedModulesByMid[$mid]);
143:         }
144:         return true;
145:     }
146: 
147:     /**
148:      * Delete a module from the database
149:      *
150:      * @param XoopsModule $module module to delete
151:      *
152:      * @return bool
153:      */
154:     public function deleteModule(XoopsModule $module)
155:     {
156:         if (!parent::delete($module)) {
157:             return false;
158:         }
159: 
160:         $mid = $module->getVar('mid');
161:         $dirname = $module->getVar('dirname');
162: 
163:         // delete admin and read permissions assigned for this module
164:         $qb = $this->db2->createXoopsQueryBuilder();
165:         $eb = $qb->expr();
166:         $qb ->deletePrefix('system_permission')
167:             ->where(
168:                 $eb->orX(
169:                     $eb->eq('gperm_name', $eb->literal('module_admin')),
170:                     $eb->eq('gperm_name', $eb->literal('module_read'))
171:                 )
172:             )
173:             ->andWhere($eb->eq('gperm_itemid', ':itemid'))
174:             ->setParameter(':itemid', $mid, \PDO::PARAM_INT)
175:             ->execute();
176: 
177:         $qb->resetQueryParts(); // reset
178:         $qb ->select('block_id')
179:             ->fromPrefix('system_blockmodule', null)
180:             ->where($eb->eq('module_id', ':mid'))
181:             ->setParameter(':mid', $mid, \PDO::PARAM_INT);
182:         $result = $qb->execute();
183:         $block_id_arr = array();
184:         while ($myrow = $result->fetch(\PDO::FETCH_ASSOC)) {
185:             array_push($block_id_arr, $myrow['block_id']);
186:         }
187: 
188:         foreach ($block_id_arr as $i) {
189:             $qb->resetQueryParts(); // reset
190:             $qb ->select('COUNT(*)')
191:                 ->fromPrefix('system_blockmodule', null)
192:                 ->where($eb->ne('module_id', ':mid'))
193:                 ->setParameter(':mid', $mid, \PDO::PARAM_INT)
194:                 ->andWhere($eb->eq('block_id', ':bid'))
195:                 ->setParameter(':bid', $i, \PDO::PARAM_INT);
196:             $result = $qb->execute();
197:             $count = $result->fetchColumn(0);
198: 
199:             if ($count > 0) {
200:                 // this block has other entries, so delete the entry for this module
201:                 $qb->resetQueryParts(); // reset
202:                 $qb ->deletePrefix('system_blockmodule')
203:                     ->where($eb->eq('module_id', ':mid'))
204:                     ->setParameter(':mid', $mid, \PDO::PARAM_INT)
205:                     ->andWhere($eb->eq('block_id', ':bid'))
206:                     ->setParameter(':bid', $i, \PDO::PARAM_INT)
207:                     ->execute();
208:             } else {
209:                 // this block does not have other entries, so disable the block and let it show
210:                 // on top page only. otherwise, this block will not display anymore on block admin page!
211:                 $qb->resetQueryParts(); // reset
212:                 $qb ->updatePrefix('system_block')
213:                     ->set('visible', ':notvisible')
214:                     ->where($eb->eq('bid', ':bid'))
215:                     ->setParameter(':bid', $i, \PDO::PARAM_INT)
216:                     ->setParameter(':notvisible', 0, \PDO::PARAM_INT)
217:                     ->execute();
218: 
219:                 $qb->resetQueryParts(); // reset
220:                 $qb ->updatePrefix('system_blockmodule')
221:                     ->set('module_id', ':nomid')
222:                     ->where($eb->eq('module_id', ':mid'))
223:                     ->setParameter(':mid', $mid, \PDO::PARAM_INT)
224:                     ->setParameter(':nomid', -1, \PDO::PARAM_INT)
225:                     ->execute();
226:             }
227:         }
228: 
229:         if (!empty($this->cachedModulesByDirname[$dirname])) {
230:             unset($this->cachedModulesByDirname[$dirname]);
231:         }
232:         if (!empty($this->cachedModulesByMid[$mid])) {
233:             unset($this->cachedModulesByMid[$mid]);
234:         }
235:         $cache = \Xoops::getInstance()->cache();
236:         $cache->delete("system/module/id/{$mid}");
237:         $cache->delete("system/module/dirname/{$dirname}");
238:         $cache->delete("module/{$dirname}");
239:         return true;
240:     }
241: 
242:     /**
243:      * Load some modules
244:      *
245:      * @param CriteriaElement|null $criteria  criteria to match
246:      * @param boolean              $id_as_key Use the ID as key into the array
247:      *
248:      * @return array
249:      */
250:     public function getObjectsArray(CriteriaElement $criteria = null, $id_as_key = false)
251:     {
252:         $ret = array();
253:         $qb = $this->db2->createXoopsQueryBuilder();
254:         $qb->select('*')->fromPrefix('system_module', null);
255:         if (isset($criteria) && ($criteria instanceof CriteriaElement)) {
256:             $criteria->setSort('weight');
257:             $criteria->renderQb($qb);
258:             $qb->addOrderBy('mid', 'ASC');
259:         }
260:         // During install, we start with no tables and no installed modules. We need to
261:         // handle the resulting exceptions and return an empty array.
262:         try {
263:             if (!$result = $qb->execute()) {
264:                 return $ret;
265:             }
266:         } catch (\Doctrine\DBAL\Driver\PDOException $e) {
267:             return $ret;
268:         } catch (\Doctrine\DBAL\Exception\TableNotFoundException $e) {
269:             return $ret;
270:         } catch (\PDOException $e) {
271:             return $ret;
272:         }
273:         while ($myrow = $result->fetch(\PDO::FETCH_ASSOC)) {
274:             $module = new XoopsModule();
275:             $module->assignVars($myrow);
276:             if (!$id_as_key) {
277:                 $ret[] = $module;
278:             } else {
279:                 $ret[$myrow['mid']] = $module;
280:             }
281:             unset($module);
282:         }
283:         return $ret;
284:     }
285: 
286:     /**
287:      * returns an array of module names
288:      *
289:      * @param CriteriaElement|null $criteria       criteria
290:      * @param boolean              $dirname_as_key true  = array key is module directory
291:      *                                             false = array key is module id
292:      *
293:      * @return array
294:      */
295:     public function getNameList(CriteriaElement $criteria = null, $dirname_as_key = false)
296:     {
297:         $ret = array();
298:         $modules = $this->getObjectsArray($criteria, true);
299:         foreach (array_keys($modules) as $i) {
300:             if (!$dirname_as_key) {
301:                 $ret[$i] = $modules[$i]->getVar('name');
302:             } else {
303:                 $ret[$modules[$i]->getVar('dirname')] = $modules[$i]->getVar('name');
304:             }
305:         }
306:         return $ret;
307:     }
308: }
309: