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: /**
 21:  * A group permission
 22:  *
 23:  * These permissions are managed through a {@link XoopsGroupPermHandler} object
 24:  *
 25:  * @package             kernel
 26:  *
 27:  * @author              Kazumi Ono  <onokazu@xoops.org>
 28:  * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
 29:  */
 30: class XoopsGroupPerm extends XoopsObject
 31: {
 32:     /**
 33:      * Constructor
 34:      *
 35:      */
 36:     public function __construct()
 37:     {
 38:         parent::__construct();
 39:         $this->initVar('gperm_id', XOBJ_DTYPE_INT, null, false);
 40:         $this->initVar('gperm_groupid', XOBJ_DTYPE_INT, null, false);
 41:         $this->initVar('gperm_itemid', XOBJ_DTYPE_INT, null, false);
 42:         $this->initVar('gperm_modid', XOBJ_DTYPE_INT, 0, false);
 43:         $this->initVar('gperm_name', XOBJ_DTYPE_OTHER, null, false);
 44:     }
 45: 
 46:     /**
 47:      * Returns Class Base Variable gperm_id
 48:      * @param string $format
 49:      * @return mixed
 50:      */
 51:     public function id($format = 'N')
 52:     {
 53:         return $this->getVar('gperm_id', $format);
 54:     }
 55: 
 56:     /**
 57:      * Returns Class Base Variable gperm_id
 58:      * @param string $format
 59:      * @return mixed
 60:      */
 61:     public function gperm_id($format = '')
 62:     {
 63:         return $this->getVar('gperm_id', $format);
 64:     }
 65: 
 66:     /**
 67:      * Returns Class Base Variable gperm_groupid
 68:      * @param string $format
 69:      * @return mixed
 70:      */
 71:     public function gperm_groupid($format = '')
 72:     {
 73:         return $this->getVar('gperm_groupid', $format);
 74:     }
 75: 
 76:     /**
 77:      * Returns Class Base Variable gperm_itemid
 78:      * @param string $format
 79:      * @return mixed
 80:      */
 81:     public function gperm_itemid($format = '')
 82:     {
 83:         return $this->getVar('gperm_itemid', $format);
 84:     }
 85: 
 86:     /**
 87:      * Returns Class Base Variable gperm_modid
 88:      * @param string $format
 89:      * @return mixed
 90:      */
 91:     public function gperm_modid($format = '')
 92:     {
 93:         return $this->getVar('gperm_modid', $format);
 94:     }
 95: 
 96:     /**
 97:      * Returns Class Base Variable gperm_name
 98:      * @param string $format
 99:      * @return mixed
100:      */
101:     public function gperm_name($format = '')
102:     {
103:         return $this->getVar('gperm_name', $format);
104:     }
105: }
106: 
107: /**
108:  * XOOPS group permission handler class.
109:  *
110:  * This class is responsible for providing data access mechanisms to the data source
111:  * of XOOPS group permission class objects.
112:  * This class is an abstract class to be implemented by child group permission classes.
113:  *
114:  * @see                 XoopsGroupPerm
115:  * @author              Kazumi Ono  <onokazu@xoops.org>
116:  * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
117:  */
118: class XoopsGroupPermHandler extends XoopsObjectHandler
119: {
120:     /**
121:      * This should be here, since this really should be a XoopsPersistableObjectHandler
122:      * Here, we fake it for future compatibility
123:      *
124:      * @var string table name
125:      */
126:     public $table;
127: 
128:     public function __construct(XoopsDatabase $db)
129:     {
130:         parent::__construct($db);
131:         $this->table = $this->db->prefix('group_permission');
132:     }
133: 
134:     /**
135:      * Create a new {@link XoopsGroupPerm}
136:      *
137:      * @param bool $isNew
138:      *
139:      * @return bool $isNew  Flag the object as "new"?
140:      */
141:     public function create($isNew = true)
142:     {
143:         $perm = new XoopsGroupPerm();
144:         if ($isNew) {
145:             $perm->setNew();
146:         }
147: 
148:         return $perm;
149:     }
150: 
151:     /**
152:      * Retrieve a group permission
153:      *
154:      * @param int $id ID
155:      *
156:      * @return XoopsGroupPerm {@link XoopsGroupPerm}, FALSE on fail
157:      */
158:     public function get($id)
159:     {
160:         $id   = (int)$id;
161:         $perm = false;
162:         if ($id > 0) {
163:             $sql = sprintf('SELECT * FROM %s WHERE gperm_id = %u', $this->db->prefix('group_permission'), $id);
164:             if (!$result = $this->db->query($sql)) {
165:                 return $perm;
166:             }
167:             $numrows = $this->db->getRowsNum($result);
168:             if ($numrows == 1) {
169:                 $perm = new XoopsGroupPerm();
170:                 $perm->assignVars($this->db->fetchArray($result));
171:             }
172:         }
173: 
174:         return $perm;
175:     }
176: 
177:     /**
178:      * Store a {@link XoopsGroupPerm}
179:      *
180:      * @param XoopsObject|XoopsGroupPerm $perm a XoopsGroupPerm object
181:      *
182:      * @return bool true on success, otherwise false
183:      */
184:     public function insert(XoopsObject $perm)
185:     {
186:         $className = 'XoopsGroupPerm';
187:         if (!($perm instanceof $className)) {
188:             return false;
189:         }
190:         if (!$perm->isDirty()) {
191:             return true;
192:         }
193:         if (!$perm->cleanVars()) {
194:             return false;
195:         }
196:         foreach ($perm->cleanVars as $k => $v) {
197:             ${$k} = $v;
198:         }
199:         if ($perm->isNew()) {
200:             $gperm_id = $this->db->genId('group_permission_gperm_id_seq');
201:             $sql      = sprintf('INSERT INTO %s (gperm_id, gperm_groupid, gperm_itemid, gperm_modid, gperm_name) VALUES (%u, %u, %u, %u, %s)', $this->db->prefix('group_permission'), $gperm_id, $gperm_groupid, $gperm_itemid, $gperm_modid, $this->db->quoteString($gperm_name));
202:         } else {
203:             $sql = sprintf('UPDATE %s SET gperm_groupid = %u, gperm_itemid = %u, gperm_modid = %u WHERE gperm_id = %u', $this->db->prefix('group_permission'), $gperm_groupid, $gperm_itemid, $gperm_modid, $gperm_id);
204:         }
205:         if (!$result = $this->db->query($sql)) {
206:             return false;
207:         }
208:         if (empty($gperm_id)) {
209:             $gperm_id = $this->db->getInsertId();
210:         }
211:         $perm->assignVar('gperm_id', $gperm_id);
212: 
213:         return true;
214:     }
215: 
216:     /**
217:      * Delete a {@link XoopsGroupPerm}
218:      *
219:      * @param XoopsObject|XoopsGroupPerm $perm a XoopsGroupPerm object
220:      *
221:      * @return bool true on success, otherwise false
222:      */
223:     public function delete(XoopsObject $perm)
224:     {
225:         $className = 'XoopsGroupPerm';
226:         if (!($perm instanceof $className)) {
227:             return false;
228:         }
229:         $sql = sprintf('DELETE FROM %s WHERE gperm_id = %u', $this->db->prefix('group_permission'), $perm->getVar('gperm_id'));
230:         if (!$result = $this->db->query($sql)) {
231:             return false;
232:         }
233: 
234:         return true;
235:     }
236: 
237:     /**
238:      * Retrieve multiple {@link XoopsGroupPerm}s
239:      *
240:      * @param CriteriaElement|CriteriaCompo $criteria  {@link CriteriaElement}
241:      * @param bool   $id_as_key Use IDs as array keys?
242:      *
243:      * @return array Array of {@link XoopsGroupPerm}s
244:      */
245:     public function getObjects(CriteriaElement $criteria = null, $id_as_key = false)
246:     {
247:         $ret   = array();
248:         $limit = $start = 0;
249:         $sql   = 'SELECT * FROM ' . $this->db->prefix('group_permission');
250:         if (isset($criteria) && is_subclass_of($criteria, 'criteriaelement')) {
251:             $sql .= ' ' . $criteria->renderWhere();
252:             $limit = $criteria->getLimit();
253:             $start = $criteria->getStart();
254:         }
255:         $result = $this->db->query($sql, $limit, $start);
256:         if (!$result) {
257:             return $ret;
258:         }
259:         while ($myrow = $this->db->fetchArray($result)) {
260:             $perm = new XoopsGroupPerm();
261:             $perm->assignVars($myrow);
262:             if (!$id_as_key) {
263:                 $ret[] =& $perm;
264:             } else {
265:                 $ret[$myrow['gperm_id']] =& $perm;
266:             }
267:             unset($perm);
268:         }
269: 
270:         return $ret;
271:     }
272: 
273:     /**
274:      * Count some {@link XoopsGroupPerm}s
275:      *
276:      * @param CriteriaElement|CriteriaCompo $criteria {@link CriteriaElement}
277:      *
278:      * @return int
279:      */
280:     public function getCount(CriteriaElement $criteria = null)
281:     {
282:         $sql = 'SELECT COUNT(*) FROM ' . $this->db->prefix('group_permission');
283:         if (isset($criteria) && is_subclass_of($criteria, 'criteriaelement')) {
284:             $sql .= ' ' . $criteria->renderWhere();
285:         }
286:         $result = $this->db->query($sql);
287:         if (!$result) {
288:             return 0;
289:         }
290:         list($count) = $this->db->fetchRow($result);
291: 
292:         return $count;
293:     }
294: 
295:     /**
296:      * Delete all permissions by a certain criteria
297:      *
298:      * @param CriteriaElement|CriteriaCompo $criteria {@link CriteriaElement}
299:      *
300:      * @return bool TRUE on success
301:      */
302:     public function deleteAll(CriteriaElement $criteria = null)
303:     {
304:         $sql = sprintf('DELETE FROM %s', $this->db->prefix('group_permission'));
305:         if (isset($criteria) && is_subclass_of($criteria, 'criteriaelement')) {
306:             $sql .= ' ' . $criteria->renderWhere();
307:         }
308:         if (!$result = $this->db->query($sql)) {
309:             return false;
310:         }
311: 
312:         return true;
313:     }
314: 
315:     /**
316:      * Delete all module specific permissions assigned for a group
317:      *
318:      * @param int $gperm_groupid ID of a group
319:      * @param int $gperm_modid   ID of a module
320:      *
321:      * @return bool TRUE on success
322:      */
323:     public function deleteByGroup($gperm_groupid, $gperm_modid = null)
324:     {
325:         $criteria = new CriteriaCompo(new Criteria('gperm_groupid', (int)$gperm_groupid));
326:         if (isset($gperm_modid)) {
327:             $criteria->add(new Criteria('gperm_modid', (int)$gperm_modid));
328:         }
329: 
330:         return $this->deleteAll($criteria);
331:     }
332: 
333:     /**
334:      * Delete all module specific permissions
335:      *
336:      * @param int    $gperm_modid  ID of a module
337:      * @param string $gperm_name   Name of a module permission
338:      * @param int    $gperm_itemid ID of a module item
339:      *
340:      * @return bool TRUE on success
341:      */
342:     public function deleteByModule($gperm_modid, $gperm_name = null, $gperm_itemid = null)
343:     {
344:         $criteria = new CriteriaCompo(new Criteria('gperm_modid', (int)$gperm_modid));
345:         if (isset($gperm_name)) {
346:             $criteria->add(new Criteria('gperm_name', $gperm_name));
347:             if (isset($gperm_itemid)) {
348:                 $criteria->add(new Criteria('gperm_itemid', (int)$gperm_itemid));
349:             }
350:         }
351: 
352:         return $this->deleteAll($criteria);
353:     }
354: 
355:     /**
356:      * Check permission
357:      *
358:      * @param string $gperm_name   Name of permission
359:      * @param int    $gperm_itemid ID of an item
360:      * @param        int           /array $gperm_groupid A group ID or an array of group IDs
361:      * @param int    $gperm_modid  ID of a module
362:      * @param bool   $trueifadmin  Returns true for admin groups
363:      *
364:      * @return bool TRUE if permission is enabled
365:      */
366:     public function checkRight($gperm_name, $gperm_itemid, $gperm_groupid, $gperm_modid = 1, $trueifadmin = true)
367:     {
368:         if (empty($gperm_groupid)) {
369:             return false;
370:         } elseif (is_array($gperm_groupid)) {
371:             if (in_array(XOOPS_GROUP_ADMIN, $gperm_groupid) && $trueifadmin) {
372:                 return true;
373:             }
374:             $criteria_group = new CriteriaCompo();
375:             foreach ($gperm_groupid as $gid) {
376:                 $criteria_group->add(new Criteria('gperm_groupid', $gid), 'OR');
377:             }
378:         } else {
379:             if (XOOPS_GROUP_ADMIN == $gperm_groupid && $trueifadmin) {
380:                 return true;
381:             }
382:             $criteria_group = new CriteriaCompo(new Criteria('gperm_groupid', $gperm_groupid));
383:         }
384:         $criteria = new CriteriaCompo(new Criteria('gperm_modid', $gperm_modid));
385:         $criteria->add($criteria_group);
386:         $criteria->add(new Criteria('gperm_name', $gperm_name));
387:         $gperm_itemid = (int)$gperm_itemid;
388:         if ($gperm_itemid > 0) {
389:             $criteria->add(new Criteria('gperm_itemid', $gperm_itemid));
390:         }
391:         return $this->getCount($criteria) > 0;
392:     }
393: 
394:     /**
395:      * Add a permission
396:      *
397:      * @param string $gperm_name    Name of permission
398:      * @param int    $gperm_itemid  ID of an item
399:      * @param int    $gperm_groupid ID of a group
400:      * @param int    $gperm_modid   ID of a module
401:      *
402:      * @return bool TRUE if success
403:      */
404:     public function addRight($gperm_name, $gperm_itemid, $gperm_groupid, $gperm_modid = 1)
405:     {
406:         /* @var $perm XoopsGroupPerm */
407:         $perm = $this->create();
408:         $perm->setVar('gperm_name', $gperm_name);
409:         $perm->setVar('gperm_groupid', $gperm_groupid);
410:         $perm->setVar('gperm_itemid', $gperm_itemid);
411:         $perm->setVar('gperm_modid', $gperm_modid);
412: 
413:         return $this->insert($perm);
414:     }
415: 
416:     /**
417:      * Get all item IDs that a group is assigned a specific permission
418:      *
419:      * @param string $gperm_name  Name of permission
420:      * @param        int          /array $gperm_groupid A group ID or an array of group IDs
421:      * @param int    $gperm_modid ID of a module
422:      *
423:      * @return array array of item IDs
424:      */
425:     public function getItemIds($gperm_name, $gperm_groupid, $gperm_modid = 1)
426:     {
427:         $ret      = array();
428:         $criteria = new CriteriaCompo(new Criteria('gperm_name', $gperm_name));
429:         $criteria->add(new Criteria('gperm_modid', (int)$gperm_modid));
430:         if (is_array($gperm_groupid)) {
431:             $criteria2 = new CriteriaCompo();
432:             foreach ($gperm_groupid as $gid) {
433:                 $criteria2->add(new Criteria('gperm_groupid', $gid), 'OR');
434:             }
435:             $criteria->add($criteria2);
436:         } else {
437:             $criteria->add(new Criteria('gperm_groupid', (int)$gperm_groupid));
438:         }
439:         $perms = $this->getObjects($criteria, true);
440:         foreach (array_keys($perms) as $i) {
441:             $ret[] = $perms[$i]->getVar('gperm_itemid');
442:         }
443: 
444:         return array_unique($ret);
445:     }
446: 
447:     /**
448:      * Get all group IDs assigned a specific permission for a particular item
449:      *
450:      * @param string $gperm_name   Name of permission
451:      * @param int    $gperm_itemid ID of an item
452:      * @param int    $gperm_modid  ID of a module
453:      *
454:      * @return array array of group IDs
455:      */
456:     public function getGroupIds($gperm_name, $gperm_itemid, $gperm_modid = 1)
457:     {
458:         $ret      = array();
459:         $criteria = new CriteriaCompo(new Criteria('gperm_name', $gperm_name));
460:         $criteria->add(new Criteria('gperm_itemid', (int)$gperm_itemid));
461:         $criteria->add(new Criteria('gperm_modid', (int)$gperm_modid));
462:         $perms = $this->getObjects($criteria, true);
463:         foreach (array_keys($perms) as $i) {
464:             $ret[] = $perms[$i]->getVar('gperm_groupid');
465:         }
466: 
467:         return $ret;
468:     }
469: }
470: