git.roojs.org Git - Pman.Core/blob - DataObjects/Core_group.php

   1 <?php
   2 /**
   3  * Table Definition for Groups
   4  *
   5  * group types
   6  *
   7  * 0 = permission group..
   8  * 1 = team
   9  * 2 = contact group
  10  *
  11  *
  12  *  NOTE - used to be called Groups ....
  13  *
  14  */
  15 class_exists('DB_DataObject') ? '' : require_once 'DB/DataObject.php';
  16
  17 class Pman_Core_DataObjects_Core_group extends DB_DataObject
  18 {
  19     ###START_AUTOCODE
  20     /* the code below is auto generated do not remove the above tag */
  21
  22     public $__table = 'core_group';                          // table name
  23     public $id;                              // int(11)  not_null primary_key auto_increment
  24     public $name;                            // string(64)  not_null
  25     public $type;                            // int(11)
  26     public $leader;                          // int(11)  not_null
  27     public $is_system;                       // used by timesheets?
  28
  29     /* the code above is auto generated do not remove the tag below */
  30     ###END_AUTOCODE
  31
  32
  33     function personTable()
  34     {
  35         $ff = HTML_FlexyFramework::get();
  36         return empty($ff->Pman['authTable']) ? 'core_person' : $ff->Pman['authTable'];
  37     }
  38
  39
  40     // group types??
  41     function applyFilters($q, $au, $roo)
  42     {
  43         if (!empty($q['query']['name_starts'])) {
  44             $v = $this->escape($q['query']['name_starts']);
  45             $this->whereAdd("{$this->tableName()}.name like '{$v}%'");
  46         }
  47
  48         if(!empty($q['_count_member_by_name'])){
  49
  50             $core_group = DB_DataObject::factory('core_group');
  51
  52             if($core_group->get('name', $q['_count_member_by_name'])){
  53                 $roo->jok($core_group->memberCount());
  54             }
  55         }
  56
  57
  58
  59 //        $cp = DB_DataObject::Factory('core_person')->tableName();
  60 //        $cgm = DB_DataObject::Factory('core_group_member')->tableName();
  61
  62         $this->selectAdd("
  63            (
  64                 SELECT
  65                         COUNT(core_group_member.user_id)
  66                 FROM
  67                         core_group_member
  68                 LEFT JOIN
  69                         core_person
  70                 ON
  71                         core_person.id = core_group_member.user_id
  72                 WHERE
  73                         core_group_member.group_id = core_group.id
  74                     AND
  75                         core_person.active = 1
  76             ) AS group_member_count
  77         ");
  78
  79         /*WHERE
  80             {$this->tableName()}.id = core_group_member.group_id
  81             AND
  82                 core_group_member.user_id = core_person.id
  83             AND
  84                 core_person.active = 1
  85         )*/
  86
  87 //        $this->whereAdd("{$this->tableName()}.id = core_group_member.group_id");
  88 //        $this->whereAdd("core_group_member.user_id = core_person.id");
  89 //        $this->whereAdd("core_person.active = 1");
  90
  91
  92         /*$cgmDBObj->joinAdd($cpObj);
  93         $this->joinAdd($cgmDBObj);
  94         DB_DataObject::debugLevel();*/
  95     }
  96
  97     function toEventString() {
  98         return $this->name;
  99     }
 100
 101     function beforeInsert($q,$roo)
 102     {
 103         if (isset($q['_action'])) {
 104             // add // sub...
 105             $g = clone($this);
 106             if (!$g->get($q['group_id'])) {
 107                 $roo->jerr("missing group id");
 108
 109             }
 110              foreach(explode(',', $q['user_ids']) as $uid) {
 111                 switch($q['_action']) {
 112                     case 'add':
 113                         $g->addMember($uid,$roo);
 114                         break;
 115                     case 'sub':
 116                         $g->removeMember($uid);
 117                         break;
 118                     default:
 119                         $roo->jerr('invalid action');
 120                 }
 121             }
 122             $roo->jok('updated');
 123
 124         }
 125
 126     }
 127
 128
 129     function beforeDelete()
 130     {
 131         $x = DB_DataObject::factory('core_group_right');
 132         $x->query("DELETE FROM {$x->tableName()} WHERE group_id = {$this->id}");
 133         $x = DB_DataObject::factory('core_group_member');
 134         $x->query("DELETE FROM {$x->tableName()} WHERE group_id = {$this->id}");
 135     }
 136     /**
 137      * check who is trying to access this. false == access denied..
 138      */
 139     function checkPerm($lvl, $au)
 140     {
 141         return $au->hasPerm("Core.Groups", $lvl);
 142     }
 143     function onUpdate($old, $req, $roo)
 144     {
 145         $this->ensureLeaderMembership($roo);
 146     }
 147     function onInsert($req, $roo)
 148     {
 149         $this->ensureLeaderMembership($roo);
 150     }
 151     function ensureLeaderMembership($roo)
 152     {
 153
 154         // groups - make sure the leader is a member...
 155         if (!$this->type || !$this->leader)
 156         {
 157             return true;
 158         }
 159
 160         $pi = DB_DataObject::factory('core_person');
 161         $pi->get($this->leader);
 162
 163         $p = DB_DataObject::factory('core_group_member');
 164         $p->group_id = $this->id;
 165         $p->user_id = $this->leader;
 166         //$p->type = 1; //???????
 167         if (!$p->count()) {
 168
 169             $p->insert();
 170             $roo->addEvent("ADD", $p, $this->toEventString(). " Added " . $pi->toEventString());
 171         }
 172
 173     }
 174
 175
 176     function memberCount()
 177     {
 178         $gm = DB_Dataobject::factory('core_group_member');
 179         $gm->group_id = $this->id;
 180         $gm->autoJoin();
 181         $gm->whereAdd('join_user_id_id.active = 1');
 182         //PDO_DAtaObject::DebugLevel(1);
 183         return $gm->count();
 184     }
 185
 186     function memberIds()
 187     {
 188         $gm = DB_Dataobject::factory('core_group_member');
 189         $gm->group_id = $this->id;
 190         $gm->autoJoin();
 191         $gm->whereAdd('join_user_id_id.active = 1');
 192         return $gm->fetchAll('user_id');
 193
 194     }
 195     function isMember($person)
 196     {
 197         $gm = DB_Dataobject::factory('core_group_member');
 198         $gm->group_id = $this->id;
 199         $gm->user_id = is_object($person) ? $person->id : $person;
 200         return $gm->count();
 201     }
 202
 203     function addMember($person,$roo = false)
 204     {
 205         if ($this->name == "Empty Group") {
 206             $roo->jerr('Cannot add the person into Empty Group');
 207         }
 208         $gm = DB_Dataobject::factory('core_group_member');
 209         $gm->group_id = $this->id;
 210         $gm->user_id = is_object($person) ? $person->id : $person;
 211         if (!$gm->count()) {
 212             $gm->insert();
 213         }
 214     }
 215
 216     function removeMember($person)
 217     {
 218         $gm = DB_Dataobject::factory('core_group_member');
 219         $gm->group_id = $this->id;
 220         $gm->user_id = is_object($person) ? $person->id : $person;
 221
 222         if ($gm->find(true)) {
 223             $gm->delete();
 224         }
 225     }
 226
 227     /**
 228      *
 229      *  grab a list of members - default is the array of person objects..
 230      *  @param $what  = set to 'email' to get a list of email addresses.
 231      *
 232      *
 233      */
 234
 235     function members($what = false)
 236     {
 237         $ids = $this->memberIds();
 238         if (!$ids) {
 239             return array();
 240         }
 241         //$p = DB_Dataobject::factory(empty($ff->Pman['authTable']) ? 'Person' : $ff->Pman['authTable']);
 242         // groups databse is hard coded to person.. so this should not be used for other tables.????
 243         $p = DB_Dataobject::factory( 'core_person' );
 244
 245         $p->whereAdd('id IN ('. implode(',', $ids) .')');
 246         $p->active = 1;
 247
 248         $p->orderBy('name');
 249         return $p->fetchAll($what);
 250     }
 251
 252
 253
 254
 255     function lookup($k,$v = false) {
 256         if ($v === false) {
 257             $v = $k;
 258             $k = 'id';
 259         }
 260         $this->get($k,$v);
 261
 262         return $this;
 263     }
 264
 265     function lookUpMembers($name, $what=false)
 266     {
 267         if (!$this->get('name', $name)) {
 268             return array();
 269         }
 270         return $this->members($what);
 271
 272     }
 273
 274     function lookupMembersByGroupId($id, $what=false)
 275     {
 276         if (!$this->get($id)) {
 277             return array();
 278         }
 279
 280         return $this->members($what);
 281     }
 282
 283     function postListFilter($ar, $au, $req)
 284     {
 285         if(empty($req['_add_everyone'])){
 286             return $ar;
 287         }
 288
 289         $ret[] = array( 'id' => 0, 'name' => 'EVERYONE');
 290         $ret[] = array( 'id' => -1, 'name' => 'NOT_IN_GROUP');
 291         return array_merge($ret, $ar);
 292
 293     }
 294
 295     function initGroups()
 296     {
 297
 298         $g = DB_DataObject::factory($this->tableName());
 299         $g->type = 0;
 300         $g->name = 'Administrators';
 301         if ($g->count()) {
 302             $g->find(true);;
 303         } else {
 304             $g->insert();
 305             $gr = DB_DataObject::factory('core_group_right');
 306             $gr->genDefault();
 307         }
 308         $m = $g->members();
 309         if (empty($m)) {
 310             $p = DB_DAtaObject::factory('core_person');
 311             $p->orderBy('id ASC');
 312             $p->limit(1);
 313             if ($p->find(true)) {
 314                 $g->addMember($p);
 315             }
 316
 317
 318         }
 319     }
 320
 321     function initDatabase($roo, $data)
 322     {
 323         $this->initGroups();
 324
 325         foreach($data as $gi) {
 326             $g = DB_DataObject::factory($this->tableName());
 327             $g->setFrom($gi);
 328
 329             if(!$g->find(true)){
 330                 $g->insert();
 331             }
 332
 333             if(count($g->members()) || empty($gi['members'])){
 334                 continue;
 335             }
 336
 337             foreach ($gi['members'] as $m){
 338                 $g->addMember($m);
 339             }
 340
 341         }
 342
 343     }
 344
 345 }