Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 6793 | | Comparar con el anterior | Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 www 1 
<?php
2 
 
3 
declare(strict_types=1);
4 
 
5 
namespace LeadersLinked\Mapper;
6 
 
7 
use Laminas\Db\Adapter\AdapterInterface;
8 
use Laminas\Db\Sql\Expression;
9 
use Laminas\Log\LoggerInterface;
10 
 
11 
use LeadersLinked\Model\User;
12 
use LeadersLinked\Mapper\Common\MapperCommon;
13 
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
14 
use Laminas\Hydrator\ArraySerializableHydrator;
15 
use Laminas\Paginator\Paginator;
16 
use Laminas\Paginator\Adapter\DbSelect;
17 
use Laminas\Db\ResultSet\HydratingResultSet;
18 
use LeadersLinked\Model\UserType;
19 
use LeadersLinked\Model\CompanyUser;
20 
use LeadersLinked\Model\CompanyMicrolearningCapsuleUser;
2083 nelberth 21 
use LeadersLinked\Model\HighPerformanceTeamsGroupsMembers;
1 www 22 
 
23 
 
1665 nelberth 24 
 
2083 nelberth 25 
 
1 www 26 
class UserMapper extends MapperCommon
27 
{
28 
    const _TABLE = 'tbl_users';
29 
 
30 
    /**
31 
     *
32 
     * @var UserMapper
33 
     */
34 
    private static $_instance;
5973 anderson 35 
 
1 www 36 
    /**
37 
     *
38 
     * @param AdapterInterface $adapter
39 
     */
40 
    private function __construct($adapter)
41 
    {
42 
        parent::__construct($adapter);
43 
    }
5973 anderson 44 
 
1 www 45 
    /**
46 
     *
47 
     * @param AdapterInterface $adapter
48 
     * @return UserMapper
49 
     */
50 
    public static function getInstance($adapter)
51 
    {
5973 anderson 52 
        if (self::$_instance == null) {
1 www 53 
            self::$_instance = new UserMapper($adapter);
54 
        }
55 
        return self::$_instance;
56 
    }
5973 anderson 57 
 
1 www 58 
    /**
59 
     *
60 
     * @param string $uuid
61 
     * @return User
62 
     */
63 
    public function fetchOneByUuid($uuid)
64 
    {
65 
        $prototype = new User();
66 
        $select = $this->sql->select(self::_TABLE);
67 
        $select->where->equalTo('uuid', $uuid);
5973 anderson 68 
 
69 
 
1 www 70 
        return $this->executeFetchOneObject($select, $prototype);
71 
    }
5973 anderson 72 
 
73 
 
1 www 74 
    /**
3639 efrain 75 
     *
4733 efrain 76 
     * @return User
77 
     */
78 
    public function fetchOneDefaultForConnection()
79 
    {
80 
        $prototype = new User();
81 
        $select = $this->sql->select(self::_TABLE);
82 
        $select->where->equalTo('default_for_connection', User::DEFAULT_FOR_CONNECTION_YES);
5973 anderson 83 
 
84 
 
4733 efrain 85 
        return $this->executeFetchOneObject($select, $prototype);
86 
    }
5973 anderson 87 
 
88 
 
89 
 
4733 efrain 90 
    /**
91 
     *
3639 efrain 92 
     * @param string $uuid
93 
     * @param int $network_id
94 
     * @return User
95 
     */
96 
    public function fetchOneByUuidAndNetworkId($uuid, $network_id)
97 
    {
98 
        $prototype = new User();
99 
        $select = $this->sql->select(self::_TABLE);
100 
        $select->where->equalTo('uuid', $uuid);
101 
        $select->where->equalTo('network_id', $network_id);
5973 anderson 102 
 
103 
 
3639 efrain 104 
        return $this->executeFetchOneObject($select, $prototype);
105 
    }
5973 anderson 106 
 
3639 efrain 107 
    /**
1 www 108 
     *
109 
     * @param int $id
110 
     * @return User
111 
     */
112 
    public function fetchOne($id)
113 
    {
114 
        $prototype = new User();
115 
        $select = $this->sql->select(self::_TABLE);
116 
        $select->where->equalTo('id', $id);
6329 anderson 117 
 
1 www 118 
        return $this->executeFetchOneObject($select, $prototype);
119 
    }
5973 anderson 120 
 
1271 nelberth 121 
    public function fetchOneRelation($id)
122 
    {
123 
        $prototype = new User();
124 
        $select = $this->sql->select(self::_TABLE);
125 
        $select->where->equalTo('id', $id);
5973 anderson 126 
 
1271 nelberth 127 
        return $this->executeFetchOneObject($select, $prototype);
128 
    }
129 
 
5973 anderson 130 
 
1 www 131 
    /**
132 
     *
133 
     * @param string $email
134 
     * @return void|User
135 
     */
136 
    public function fetchOneByEmail($email)
137 
    {
138 
        $prototype = new User();
139 
        $select = $this->sql->select(self::_TABLE);
140 
        $select->where->equalTo('email', $email);
5973 anderson 141 
 
1 www 142 
        //echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 143 
 
1 www 144 
        return $this->executeFetchOneObject($select, $prototype);
145 
    }
5973 anderson 146 
 
1 www 147 
    /**
3639 efrain 148 
     *
149 
     * @param string $email
150 
     * @param int $network_id
151 
     * @return void|User
152 
     */
153 
    public function fetchOneByEmailAndNetworkId($email, $network_id)
154 
    {
155 
        $prototype = new User();
156 
        $select = $this->sql->select(self::_TABLE);
157 
        $select->where->equalTo('email', $email);
158 
        $select->where->equalTo('network_id', $network_id);
5973 anderson 159 
 
3639 efrain 160 
        //echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 161 
 
3639 efrain 162 
        return $this->executeFetchOneObject($select, $prototype);
163 
    }
5973 anderson 164 
 
3639 efrain 165 
    /**
5050 efrain 166 
     *
167 
     * @param string $email
168 
     * @param int $network_id
169 
     * @return void|User
170 
     */
171 
    public function fetchOneActiveByEmailAndNetworkId($email, $network_id)
172 
    {
173 
        $prototype = new User();
174 
        $select = $this->sql->select(self::_TABLE);
175 
        $select->where->equalTo('email', $email);
176 
        $select->where->equalTo('network_id', $network_id);
177 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
178 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 179 
 
5050 efrain 180 
        //echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 181 
 
5050 efrain 182 
        return $this->executeFetchOneObject($select, $prototype);
183 
    }
5973 anderson 184 
 
185 
 
186 
 
5050 efrain 187 
    /**
1 www 188 
     *
189 
     * @param string $password_reset_key
190 
     * @return void|User
191 
     */
192 
    public function fetchOneByPasswordResetKey($password_reset_key)
193 
    {
194 
        $prototype = new User();
195 
        $select = $this->sql->select(self::_TABLE);
196 
        $select->where->equalTo('password_reset_key', $password_reset_key);
5973 anderson 197 
 
1 www 198 
        return $this->executeFetchOneObject($select, $prototype);
199 
    }
5973 anderson 200 
 
201 
 
1 www 202 
    /**
3649 efrain 203 
     *
204 
     * @param string $password_reset_key
205 
     * @param int $network_id
206 
     * @return void|User
207 
     */
208 
    public function fetchOneByPasswordResetKeyAndNetworkId($password_reset_key, $network_id)
209 
    {
210 
        $prototype = new User();
211 
        $select = $this->sql->select(self::_TABLE);
212 
        $select->where->equalTo('password_reset_key', $password_reset_key);
213 
        $select->where->equalTo('network_id', $network_id);
5973 anderson 214 
 
3649 efrain 215 
        return $this->executeFetchOneObject($select, $prototype);
216 
    }
5973 anderson 217 
 
3649 efrain 218 
    /**
1 www 219 
     *
220 
     * @param string $activation_key
221 
     * @return void|User
222 
     */
223 
    public function fetchOneByActivationKey($activation_key)
224 
    {
225 
        $prototype = new User();
226 
        $select = $this->sql->select(self::_TABLE);
227 
        $select->where->equalTo('activation_key', $activation_key);
5973 anderson 228 
 
1 www 229 
        return $this->executeFetchOneObject($select, $prototype);
230 
    }
5973 anderson 231 
 
3649 efrain 232 
    /**
233 
     *
234 
     * @param string $activation_key
235 
     * @param int $network_id
236 
     * @return void|User
237 
     */
3759 efrain 238 
    public function fetchOneByActivationKeyAndNetworkId($activation_key, $network_id)
3649 efrain 239 
    {
240 
        $prototype = new User();
241 
        $select = $this->sql->select(self::_TABLE);
242 
        $select->where->equalTo('activation_key', $activation_key);
243 
        $select->where->equalTo('network_id', $network_id);
3671 efrain 244 
 
5973 anderson 245 
 
246 
 
3649 efrain 247 
        return $this->executeFetchOneObject($select, $prototype);
248 
    }
5973 anderson 249 
 
250 
 
3639 efrain 251 
    /**
252 
     *
253 
     * @param int $network_id
254 
     * @return int
255 
     */
256 
    public function fetchCountByNetworkId($network_id)
257 
    {
5973 anderson 258 
 
3639 efrain 259 
        $select = $this->sql->select(self::_TABLE);
260 
        $select->columns(['total' => new Expression('COUNT(*)')]);
261 
        $select->where->equalTo('network_id', $network_id);
5973 anderson 262 
 
3639 efrain 263 
        $record = $this->executeFetchOneArray($select);
5973 anderson 264 
 
3639 efrain 265 
        return $record['total'];
266 
    }
5973 anderson 267 
 
4842 efrain 268 
    /**
269 
     *
270 
     * @param int $network_id
271 
     * @return int
272 
     */
273 
    public function fetchCountActiveByDefaultNetworkId($network_id)
274 
    {
5973 anderson 275 
 
4842 efrain 276 
        $select = $this->sql->select(self::_TABLE);
277 
        $select->columns(['total' => new Expression('COUNT(*)')]);
278 
        $select->where->equalTo('network_id', $network_id);
279 
        $select->where->in('usertype_id', [UserType::USER, UserType::ADMIN]);
280 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
5973 anderson 281 
 
4842 efrain 282 
        $record = $this->executeFetchOneArray($select);
5973 anderson 283 
 
4842 efrain 284 
        return $record['total'];
285 
    }
5973 anderson 286 
 
4842 efrain 287 
    /**
288 
     *
289 
     * @param int $network_id
290 
     * @return int
291 
     */
292 
    public function fetchCountActiveByOtherNetworkId($network_id)
293 
    {
5973 anderson 294 
 
4842 efrain 295 
        $select = $this->sql->select(self::_TABLE);
296 
        $select->columns(['total' => new Expression('COUNT(*)')]);
297 
        $select->where->equalTo('network_id', $network_id);
298 
        $select->where->in('usertype_id', [UserType::USER, UserType::ADMIN]);
299 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
300 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
301 
 
5973 anderson 302 
 
4842 efrain 303 
        $record = $this->executeFetchOneArray($select);
5973 anderson 304 
 
4842 efrain 305 
        return $record['total'];
306 
    }
1 www 307 
 
5973 anderson 308 
 
309 
 
1 www 310 
    /**
311 
     *
312 
     * @param string $keyword
313 
     * @param int $current_user
314 
     * @return User[]
315 
     */
316 
    public function fetchAllByKeyword($keyword, $current_user = 0)
317 
    {
5973 anderson 318 
 
1 www 319 
        $prototype = new User();
320 
 
321 
        $select = $this->sql->select(self::_TABLE);
5973 anderson 322 
 
1 www 323 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
324 
        $select->where->notEqualTo('id', $current_user);
325 
        $select->where->and->nest()
326 
            ->like('first_name', '%' . $keyword . '%')
327 
            ->or->like('last_name', '%' . $keyword . '%')
5973 anderson 328 
            ->or->like(new Expression("CONCAT(first_name,' ',last_name)"), '%' . $keyword . '%')
1 www 329 
            ->unnest();
5973 anderson 330 
 
331 
 
1 www 332 
        return $this->executeFetchAllObject($select, $prototype);
333 
    }
5973 anderson 334 
 
1 www 335 
    /**
336 
     *
337 
     * @param int[] $ids
338 
     * @param int $current_user
339 
     * @param string $status
340 
     * @return User[]
341 
     */
342 
    public function fetchAllByIds($ids, $current_user = 0, $status = User::STATUS_ACTIVE)
343 
    {
5973 anderson 344 
 
1 www 345 
        $prototype = new User();
346 
        $select = $this->sql->select(self::_TABLE);
5973 anderson 347 
 
348 
 
1 www 349 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
5973 anderson 350 
        $select->where->and->in('id', $ids);
351 
 
352 
        if ($current_user) {
1 www 353 
            $select->where->and->notEqualTo('id ', $current_user);
354 
        }
630 efrain 355 
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
5973 anderson 356 
 
1 www 357 
        return $this->executeFetchAllObject($select, $prototype);
358 
    }
5973 anderson 359 
 
4857 efrain 360 
    /**
361 
     *
362 
     * @param int[] $ids
363 
     * @param string $search
364 
     * @param int $current_user
365 
     * @param string $status
366 
     * @return User[]
367 
     */
368 
    public function fetchAllByIdsAndSearch($ids, $search, $current_user = 0, $status = User::STATUS_ACTIVE)
369 
    {
5973 anderson 370 
 
4857 efrain 371 
        $prototype = new User();
372 
        $select = $this->sql->select(self::_TABLE);
5973 anderson 373 
 
374 
 
4857 efrain 375 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
5973 anderson 376 
        $select->where->and->in('id', $ids);
4857 efrain 377 
        $select->where->nest()
5973 anderson 378 
            ->like('first_name', '%' . $search . '%')
379 
            ->or->like('last_name', '%' . $search . '%')
6031 anderson 380 
            ->or->like(new Expression("CONCAT(first_name,' ',last_name)"), '%' . $search . '%')
381 
            ->or->like(new Expression("CONCAT(last_name,' ',first_name)"), '%' . $search . '%')
5973 anderson 382 
            ->or->like('email', '%' . $search . '%')->unnest();
383 
 
384 
        if ($current_user) {
4857 efrain 385 
            $select->where->and->notEqualTo('id ', $current_user);
386 
        }
387 
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
5973 anderson 388 
 
4857 efrain 389 
        return $this->executeFetchAllObject($select, $prototype);
390 
    }
391 
 
5973 anderson 392 
 
6023 anderson 393 
 
6011 efrain 394 
    /**
395 
     *
396 
     * @param int $network_id
397 
     * @param int[] $ids
398 
     * @param string $search
399 
     * @param int $current_user
400 
     * @param string $status
401 
     * @return User[]
402 
     */
403 
    public function fetchAllByNetworkIdAndIdsAndSearch($network_id, $ids, $search, $current_user = 0, $status = User::STATUS_ACTIVE)
404 
    {
6023 anderson 405 
 
6011 efrain 406 
        $prototype = new User();
407 
        $select = $this->sql->select(self::_TABLE);
6023 anderson 408 
 
409 
 
6011 efrain 410 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
411 
        $select->where->equalTo('network_id', $network_id);
412 
        $select->where->and->in('id', $ids);
413 
        $select->where->nest()
6023 anderson 414 
            ->like('first_name', '%' . $search . '%')
415 
            ->or->like('last_name', '%' . $search . '%')
416 
            ->or->like('email', '%' . $search . '%')->unnest();
417 
 
6011 efrain 418 
        if ($current_user) {
419 
            $select->where->and->notEqualTo('id ', $current_user);
420 
        }
421 
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
6023 anderson 422 
 
6011 efrain 423 
        return $this->executeFetchAllObject($select, $prototype);
424 
    }
5973 anderson 425 
 
426 
 
427 
 
428 
 
1 www 429 
    /**
430 
     *
431 
     * @return User[]
432 
     */
433 
    public function fetchAllByActives()
434 
    {
5973 anderson 435 
 
1 www 436 
        $prototype = new User();
437 
        $select = $this->sql->select(self::_TABLE);
5973 anderson 438 
 
439 
 
1 www 440 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
5973 anderson 441 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
442 
 
646 efrain 443 
        $select->order(['first_name DESC, last_name DESC, email_DESC']);
1 www 444 
 
5973 anderson 445 
 
1 www 446 
        return $this->executeFetchAllObject($select, $prototype);
447 
    }
5973 anderson 448 
 
1 www 449 
    /**
4857 efrain 450 
     *
451 
     * @param int $network_id
452 
     * @param int $current_user_id;
453 
     * @return int[]
454 
     */
455 
    public function fetchAllIdsByDefaultNetworkId($network_id, $current_user_id = 0)
456 
    {
457 
 
5973 anderson 458 
 
4857 efrain 459 
        $select = $this->sql->select(self::_TABLE);
460 
        $select->columns(['id']);
461 
        $select->where->equalTo('network_id', $network_id);
462 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
463 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
6011 efrain 464 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 465 
 
466 
        if ($current_user_id) {
4857 efrain 467 
            $select->where->notEqualTo('id', $current_user_id);
468 
        }
5973 anderson 469 
 
4857 efrain 470 
        $ids = [];
5973 anderson 471 
 
4857 efrain 472 
        $records = $this->executeFetchAllArray($select);
5973 anderson 473 
        foreach ($records as $record) {
4857 efrain 474 
            array_push($ids, $record['id']);
475 
        }
5973 anderson 476 
 
4857 efrain 477 
        return $ids;
478 
    }
5973 anderson 479 
 
4857 efrain 480 
    /**
481 
     *
482 
     * @param int $network_id
483 
     * @param string $search
484 
     * @param int $current_user_id;
485 
     * @return int[]
486 
     */
487 
    public function fetchAllIdsByDefaultNetworkIdAndSearch($network_id, $search, $current_user_id = 0)
488 
    {
5973 anderson 489 
 
490 
 
4857 efrain 491 
        $select = $this->sql->select(self::_TABLE);
492 
        $select->columns(['id']);
493 
        $select->where->equalTo('network_id', $network_id);
494 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
495 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
496 
        $select->where->nest()
5973 anderson 497 
            ->like('first_name', '%' . $search . '%')
498 
            ->or->like('last_name', '%' . $search . '%')
499 
            ->or->like('email', '%' . $search . '%')->unnest();
500 
 
501 
        if ($current_user_id) {
4857 efrain 502 
            $select->where->notEqualTo('id', $current_user_id);
503 
        }
5973 anderson 504 
 
4857 efrain 505 
        $ids = [];
5973 anderson 506 
 
4857 efrain 507 
        $records = $this->executeFetchAllArray($select);
5973 anderson 508 
        foreach ($records as $record) {
4857 efrain 509 
            array_push($ids, $record['id']);
510 
        }
5973 anderson 511 
 
4857 efrain 512 
        return $ids;
513 
    }
5973 anderson 514 
 
4857 efrain 515 
    /**
516 
     *
517 
     * @param int $network_id
518 
     * @param int $current_user_id;
519 
     * @return int[]
520 
     */
521 
    public function fetchAllIdsByNonDefaultNetworkId($network_id, $current_user_id = 0)
522 
    {
5973 anderson 523 
 
524 
 
4857 efrain 525 
        $select = $this->sql->select(self::_TABLE);
526 
        $select->columns(['id']);
527 
        $select->where->equalTo('network_id', $network_id);
528 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
529 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
6011 efrain 530 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
4857 efrain 531 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
5973 anderson 532 
 
533 
        if ($current_user_id) {
4857 efrain 534 
            $select->where->notEqualTo('id', $current_user_id);
535 
        }
5973 anderson 536 
 
4857 efrain 537 
        $ids = [];
5973 anderson 538 
 
4857 efrain 539 
        $records = $this->executeFetchAllArray($select);
5973 anderson 540 
        foreach ($records as $record) {
4857 efrain 541 
            array_push($ids, $record['id']);
542 
        }
5973 anderson 543 
 
4857 efrain 544 
        return $ids;
545 
    }
5973 anderson 546 
 
547 
 
4857 efrain 548 
    /**
549 
     *
550 
     * @param int $network_id
551 
     * @param string $search
552 
     * @param int $current_user_id;
553 
     * @return int[]
554 
     */
555 
    public function fetchAllIdsByNonDefaultNetworkIdAndSearch($network_id, $search, $current_user_id = 0)
556 
    {
5973 anderson 557 
 
558 
 
4857 efrain 559 
        $select = $this->sql->select(self::_TABLE);
560 
        $select->columns(['id']);
561 
        $select->where->equalTo('network_id', $network_id);
562 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
563 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
564 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
565 
        $select->where->nest()
5973 anderson 566 
            ->like('first_name', '%' . $search . '%')
567 
            ->or->like('last_name', '%' . $search . '%')
568 
            ->or->like('email', '%' . $search . '%')->unnest();
569 
 
570 
        if ($current_user_id) {
4857 efrain 571 
            $select->where->notEqualTo('id', $current_user_id);
572 
        }
5973 anderson 573 
 
574 
 
4857 efrain 575 
        $ids = [];
5973 anderson 576 
 
4857 efrain 577 
        $records = $this->executeFetchAllArray($select);
5973 anderson 578 
        foreach ($records as $record) {
4857 efrain 579 
            array_push($ids, $record['id']);
580 
        }
5973 anderson 581 
 
4857 efrain 582 
        return $ids;
583 
    }
5973 anderson 584 
 
585 
 
4857 efrain 586 
    /**
1 www 587 
     *
646 efrain 588 
     * @param int $company_id
5751 efrain 589 
     * @return User[]
646 efrain 590 
     */
591 
    public function fetchAllByCompanyId($company_id)
592 
    {
5973 anderson 593 
 
646 efrain 594 
        $prototype = new User();
595 
        $select = $this->sql->select();
596 
        $select->from(['tb1' => self::_TABLE]);
597 
        $select->join(['tb2' => CompanyUserMapper::_TABLE], 'tb1.id = tb2.user_id', []);
5973 anderson 598 
 
599 
 
646 efrain 600 
        $select->where->equalTo('tb2.company_id', $company_id);
601 
        $select->where->in('tb2.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
5973 anderson 602 
 
646 efrain 603 
        $select->where->equalTo('tb1.status', User::STATUS_ACTIVE);
5973 anderson 604 
        $select->where->equalTo('tb1.email_verified', User::EMAIL_VERIFIED_YES);
605 
 
646 efrain 606 
        $select->order(['first_name DESC, last_name DESC, email_DESC']);
5973 anderson 607 
 
608 
 
609 
 
646 efrain 610 
        return $this->executeFetchAllObject($select, $prototype);
611 
    }
5973 anderson 612 
 
646 efrain 613 
    /**
614 
     *
1 www 615 
     * @param int $user_id
3639 efrain 616 
     * @return boolean
617 
     */
618 
    public function leaveImpersonate($user_id)
619 
    {
620 
        $values = [
621 
            'impersonate_user_id' => new Expression('NULL')
622 
        ];
5973 anderson 623 
 
3639 efrain 624 
        $update = $this->sql->update(self::_TABLE);
625 
        $update->set($values);
626 
        $update->where->equalTo('id', $user_id);
5973 anderson 627 
 
3639 efrain 628 
        return $this->executeUpdate($update);
629 
    }
5973 anderson 630 
 
3639 efrain 631 
    /**
632 
     *
633 
     * @param int $user_id
634 
     * @param int $impersonate_user_id
635 
     * @return boolean
636 
     */
637 
    public function startImpersonate($user_id, $impersonate_user_id)
638 
    {
639 
        $values = [
640 
            'impersonate_user_id' => $impersonate_user_id
641 
        ];
5973 anderson 642 
 
3639 efrain 643 
        $update = $this->sql->update(self::_TABLE);
644 
        $update->set($values);
645 
        $update->where->equalTo('id', $user_id);
5973 anderson 646 
 
3639 efrain 647 
        return $this->executeUpdate($update);
648 
    }
5973 anderson 649 
 
3639 efrain 650 
    /**
651 
     *
652 
     * @param int $user_id
1 www 653 
     * @param string $password_reset_key
654 
     * @return boolean
655 
     */
656 
    public function updatePasswordResetKey($user_id, $password_reset_key)
657 
    {
658 
        $values = [
659 
            'password_reset_key' => $password_reset_key,
660 
            'password_generated_on' => date('Y-m-d H:i:s'),
661 
            'updated_on' => new Expression('NOW()')
662 
        ];
663 
 
664 
        $update = $this->sql->update(self::_TABLE);
665 
        $update->set($values);
666 
        $update->where->equalTo('id', $user_id);
5973 anderson 667 
 
1 www 668 
        return $this->executeUpdate($update);
669 
    }
5973 anderson 670 
 
671 
 
1979 efrain 672 
    /**
673 
     *
674 
     * @param int $user_id
675 
     * @param string $delete_account_key
676 
     * @return boolean
677 
     */
678 
    public function updateDeleteAccountKey($user_id, $delete_account_key)
679 
    {
680 
        $values = [
681 
            'delete_account_key' => $delete_account_key,
682 
            'delete_account_generated_on' => date('Y-m-d H:i:s'),
683 
            'updated_on' => new Expression('NOW()')
684 
        ];
5973 anderson 685 
 
1979 efrain 686 
        $update = $this->sql->update(self::_TABLE);
687 
        $update->set($values);
688 
        $update->where->equalTo('id', $user_id);
5973 anderson 689 
 
1979 efrain 690 
        return $this->executeUpdate($update);
691 
    }
1 www 692 
 
5973 anderson 693 
 
694 
 
1 www 695 
    /**
696 
     *
697 
     * @param User $user
698 
     * @param string $password_hash
699 
     * @return boolean
700 
     */
701 
    public function updatePassword($user, $password_hash)
702 
    {
703 
        $values = [
704 
            'password'              => $password_hash,
705 
            'password_reset_key'    => '',
706 
            'password_updated_on'   => date('Y-m-d H:i:s'),
707 
            'login_attempt'         => 0,
708 
            'blocked'               => User::BLOCKED_NO,
709 
            'updated_on'            => new Expression('NOW()')
710 
        ];
5973 anderson 711 
 
1 www 712 
        $update = $this->sql->update(self::_TABLE);
713 
        $update->set($values);
714 
        $update->where->equalTo('id', $user->id);
5973 anderson 715 
 
1 www 716 
        return $this->executeUpdate($update);
717 
    }
5973 anderson 718 
 
719 
 
720 
 
1 www 721 
    /**
722 
     *
723 
     * @param User $user
5935 efrain 724 
     * @param int $usertype_id
1 www 725 
     * @return boolean
726 
     */
5935 efrain 727 
    public function updateUserTypeId($user, $usertype_id)
728 
    {
729 
        $values = [
730 
            'usertype_id'   => $usertype_id,
731 
            'updated_on'    => new Expression('NOW()')
732 
        ];
5973 anderson 733 
 
5935 efrain 734 
        $update = $this->sql->update(self::_TABLE);
735 
        $update->set($values);
736 
        $update->where->equalTo('id', $user->id);
5973 anderson 737 
 
5935 efrain 738 
        return $this->executeUpdate($update);
739 
    }
5973 anderson 740 
 
741 
 
5935 efrain 742 
    /**
743 
     *
744 
     * @param User $user
745 
     * @return boolean
746 
     */
1 www 747 
    public function unblock($user)
748 
    {
749 
        $values = [
750 
            'login_attempt'         => 0,
751 
            'blocked'               => User::BLOCKED_NO,
752 
            'updated_on'            => new Expression('NOW()')
753 
        ];
5973 anderson 754 
 
1 www 755 
        $update = $this->sql->update(self::_TABLE);
756 
        $update->set($values);
757 
        $update->where->equalTo('id', $user->id);
5973 anderson 758 
 
1 www 759 
        return $this->executeUpdate($update);
760 
    }
5973 anderson 761 
 
762 
 
763 
 
764 
 
1 www 765 
    /**
766 
     *
767 
     * @param User $user
768 
     * @param string $one_time_password
769 
     * @return boolean
770 
     */
771 
    public function updateOneTimePassword($user, $one_time_password)
772 
    {
773 
        $values = [
774 
            'one_time_password' => $one_time_password,
775 
            'updated_on'        => new Expression('NOW()')
776 
        ];
5973 anderson 777 
 
1 www 778 
        $update = $this->sql->update(self::_TABLE);
779 
        $update->set($values);
780 
        $update->where->equalTo('id', $user->id);
5973 anderson 781 
 
1 www 782 
        return $this->executeUpdate($update);
783 
    }
5973 anderson 784 
 
785 
 
1 www 786 
    /**
787 
     *
788 
     * @param User $user
789 
     * @return boolean
790 
     */
791 
    public function update($user)
792 
    {
793 
        $hydrator = new ObjectPropertyHydrator();
794 
        $values = $hydrator->extract($user);
1979 efrain 795 
        //$values = $this->removeEmpty($values);
796 
 
797 
 
798 
        unset($values['added_on']);
5973 anderson 799 
        $values['updated_on'] = new Expression('NOW()');
800 
 
1 www 801 
        $update = $this->sql->update(self::_TABLE);
802 
        $update->set($values);
5973 anderson 803 
        $update->where->equalTo('id', $user->id);
804 
 
1979 efrain 805 
        //echo $update->getSqlString($this->adapter->platform); exit;
5973 anderson 806 
 
1 www 807 
        return $this->executeUpdate($update);
808 
    }
5973 anderson 809 
 
1 www 810 
    /**
811 
     *
812 
     * @param User $user
813 
     * @return boolean
814 
     */
815 
    public function updatePrivacy($user)
816 
    {
817 
        $values = [
818 
            'show_in_search' => $user->show_in_search,
819 
            'updated_on' => new Expression('NOW()')
820 
        ];
5973 anderson 821 
 
1 www 822 
        $update = $this->sql->update(self::_TABLE);
823 
        $update->set($values);
5973 anderson 824 
        $update->where->equalTo('id', $user->id);
825 
 
1 www 826 
        return $this->executeUpdate($update);
827 
    }
5973 anderson 828 
 
1 www 829 
    /**
830 
     *
831 
     * @param User $user
832 
     * @return boolean
833 
     */
834 
    public function updateBasic($user)
835 
    {
836 
        $values = [
837 
            'first_name' => $user->first_name,
838 
            'last_name' => $user->last_name,
839 
            'phone' => $user->phone,
840 
            'gender' => $user->gender,
4113 efrain 841 
            'timezone' => $user->timezone,
4416 efrain 842 
            'is_adult' => $user->is_adult,
1 www 843 
            'updated_on' => new Expression('NOW()')
844 
        ];
5973 anderson 845 
 
1 www 846 
        $update = $this->sql->update(self::_TABLE);
847 
        $update->set($values);
5973 anderson 848 
        $update->where->equalTo('id', $user->id);
849 
 
1 www 850 
        return $this->executeUpdate($update);
851 
    }
5973 anderson 852 
 
6749 efrain 853 
 
854 
    /**
855 
     *
856 
     * @param User $user
857 
     * @return boolean
858 
     */
859 
    public function updateFirstNameAndLastName($user)
860 
    {
861 
        $values = [
862 
            'first_name' => $user->first_name,
863 
            'last_name' => $user->last_name,
864 
            'updated_on' => new Expression('NOW()')
865 
        ];
866 
 
867 
        $update = $this->sql->update(self::_TABLE);
868 
        $update->set($values);
869 
        $update->where->equalTo('id', $user->id);
870 
 
871 
        return $this->executeUpdate($update);
872 
    }
873 
 
5973 anderson 874 
 
1 www 875 
    /**
876 
     *
877 
     * @param User $user
878 
     * @return boolean
879 
     */
880 
    public function updateImage($user)
881 
    {
882 
        $values = [
883 
            'image' => $user->image,
884 
            'updated_on' => new Expression('NOW()')
885 
        ];
5973 anderson 886 
 
1 www 887 
        $update = $this->sql->update(self::_TABLE);
888 
        $update->set($values);
5973 anderson 889 
        $update->where->equalTo('id', $user->id);
890 
 
1 www 891 
        return $this->executeUpdate($update);
892 
    }
5973 anderson 893 
 
1 www 894 
    /**
895 
     *
896 
     * @param User $user
897 
     * @return boolean
898 
     */
899 
    public function updateLocation($user)
900 
    {
901 
        $values = [
902 
            'location_id' => $user->location_id,
903 
            'updated_on' => new Expression('NOW()')
904 
        ];
5973 anderson 905 
 
1 www 906 
        $update = $this->sql->update(self::_TABLE);
907 
        $update->set($values);
5973 anderson 908 
        $update->where->equalTo('id', $user->id);
909 
 
1 www 910 
        return $this->executeUpdate($update);
911 
    }
5973 anderson 912 
 
1 www 913 
    /**
914 
     *
915 
     * @param int $user_id
916 
     * @return boolean
917 
     */
918 
    public function activateAccount($user_id)
919 
    {
920 
        $values = [
921 
            'email_verified'    => User::EMAIL_VERIFIED_YES,
922 
            'status'            => User::STATUS_ACTIVE,
923 
            'activation_key'    => '',
924 
            'updated_on' => new Expression('NOW()')
925 
        ];
5973 anderson 926 
 
1 www 927 
        $update = $this->sql->update(self::_TABLE);
928 
        $update->set($values);
929 
        $update->where->equalTo('id', $user_id);
5973 anderson 930 
 
1 www 931 
        return $this->executeUpdate($update);
932 
    }
5973 anderson 933 
 
1 www 934 
    /**
935 
     *
936 
     * @param User $user
937 
     * @return boolean
938 
     */
939 
    public function insert($user)
940 
    {
5973 anderson 941 
 
1 www 942 
        $hydrator = new ObjectPropertyHydrator();
943 
        $values = $hydrator->extract($user);
944 
        $values = $this->removeEmpty($values);
5973 anderson 945 
 
1 www 946 
        $insert = $this->sql->insert(self::_TABLE);
947 
        $insert->values($values);
5973 anderson 948 
 
1 www 949 
        $response = $this->executeInsert($insert);
5973 anderson 950 
        if ($response) {
1 www 951 
            $user->id = $this->lastInsertId;
952 
        }
5973 anderson 953 
 
1 www 954 
        return $response;
955 
    }
5973 anderson 956 
 
957 
 
1 www 958 
    /**
959 
     *
960 
     * @return boolean
961 
     */
962 
    public function truncate()
963 
    {
964 
        $sql = sprintf('TRUNCATE TABLE `%s` ', self::_TABLE);
965 
        return $this->executeSentenceWithParameters($sql);
966 
    }
5973 anderson 967 
 
1 www 968 
    /**
969 
     *
970 
     * @param int $company_id
971 
     * @param string $status
972 
     * @param string $search
973 
     * @param int $page
974 
     * @param int $records_per_page
975 
     * @param string $order_field
976 
     * @param string $order_direction
977 
     * @return Paginator
978 
     */
6793 efrain 979 
    public function fetchAllDataTableByCompanyId($company_id,  $search, $status = '', $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 980 
    {
5973 anderson 981 
        $select = $this->sql->select();
1 www 982 
        $select->columns(['status', 'backend', 'creator']);
983 
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
5973 anderson 984 
        $select->join(['tb2' => self::_TABLE], 'tb1.user_id = tb2.id', [
1 www 985 
            'id', 'uuid', 'first_name', 'last_name', 'email', 'last_activity_on', 'image',
986 
            'blocked', 'login_attempt', 'email_verified'
5973 anderson 987 
 
1 www 988 
        ]);
5973 anderson 989 
 
1 www 990 
        $select->where->equalTo('tb1.company_id', $company_id);
991 
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
5973 anderson 992 
 
993 
        if ($status) {
994 
            $select->where->equalTo('tb1.status', $status);
995 
        }
996 
 
997 
        if ($search) {
1 www 998 
            $select->where->nest()
5973 anderson 999 
                ->like('first_name', '%' . $search . '%')
1000 
                ->or->like('last_name', '%' . $search . '%')
1001 
                ->or->like('email', '%' . $search . '%')
1002 
                ->unnest();
1 www 1003 
        }
5973 anderson 1004 
 
1005 
 
1 www 1006 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1007 
 
1 www 1008 
        $hydrator   = new ArraySerializableHydrator();
1009 
        $resultset  = new HydratingResultSet($hydrator);
5973 anderson 1010 
 
1 www 1011 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1012 
        $paginator = new Paginator($adapter);
1013 
        $paginator->setItemCountPerPage($records_per_page);
1014 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1015 
 
1016 
 
1 www 1017 
        return $paginator;
1018 
    }
5973 anderson 1019 
 
1020 
 
1 www 1021 
    /**
1022 
     *
1023 
     * @param int $company_id
1024 
     * @param string $search
1025 
     * @param int $page
1026 
     * @param int $records_per_page
1027 
     * @param string $order_field
1028 
     * @param string $order_direction
1029 
     * @return Paginator
1030 
     */
5973 anderson 1031 
    public function fetchAllDataTableStudensByCompanyId($company_id,  $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 1032 
    {
1033 
        $date = date('Y-m-d');
5973 anderson 1034 
 
1 www 1035 
        $selectCapsuleUser = $this->getSql()->select();
5973 anderson 1036 
        $selectCapsuleUser->columns(['user_id' => new Expression('DISTINCT(user_id)')]);
1037 
        $selectCapsuleUser->from(CompanyMicrolearningCapsuleUserMapper::_TABLE);
1 www 1038 
        $selectCapsuleUser->where->equalTo('company_id', $company_id);
1039 
        $selectCapsuleUser->where->nest->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_UNLIMITED)->or->nest()
5973 anderson 1040 
            ->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_PAY_PERIOD)
1041 
            ->and->lessThanOrEqualTo(new Expression('DATE(paid_from)'), $date)
1042 
            ->and->greaterThanOrEqualTo(new Expression('DATE(paid_to)'), $date)->unnest()->unnest();
1043 
 
1 www 1044 
        //echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1045 
 
1 www 1046 
        $select = $this->sql->select();
5973 anderson 1047 
        $select->columns(['id', 'uuid', 'first_name', 'last_name', 'email', 'blocked']);
1 www 1048 
        $select->from(UserMapper::_TABLE);
1049 
        $select->where->in('id', $selectCapsuleUser);
1050 
 
5973 anderson 1051 
 
1052 
        if ($search) {
1 www 1053 
            $select->where->nest()
5973 anderson 1054 
                ->like('first_name', '%' . $search . '%')
1055 
                ->or->like('last_name', '%' . $search . '%')
1056 
                ->or->like('email', '%' . $search . '%')
1057 
                ->unnest();
1 www 1058 
        }
5973 anderson 1059 
 
1060 
 
1 www 1061 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1062 
 
1 www 1063 
        $hydrator   = new ArraySerializableHydrator();
1064 
        $resultset  = new HydratingResultSet($hydrator);
5973 anderson 1065 
 
1 www 1066 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1067 
        $paginator = new Paginator($adapter);
1068 
        $paginator->setItemCountPerPage($records_per_page);
1069 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1070 
 
1071 
 
1 www 1072 
        return $paginator;
1073 
    }
2381 nelberth 1074 
 
5973 anderson 1075 
 
1 www 1076 
    /**
1077 
     *
2381 nelberth 1078 
     * @param int $company_id
1 www 1079 
     * @param string $search
2381 nelberth 1080 
     * @param int $page
1081 
     * @param int $records_per_page
1082 
     * @param string $order_field
1083 
     * @param string $order_direction
1084 
     * @return Paginator
1085 
     */
1086 
    public function fetchAllStudensByCompanyId($company_id)
1087 
    {
5973 anderson 1088 
 
2381 nelberth 1089 
        $date = date('Y-m-d');
5973 anderson 1090 
 
2381 nelberth 1091 
        $selectCapsuleUser = $this->getSql()->select();
5973 anderson 1092 
        $selectCapsuleUser->columns(['user_id' => new Expression('DISTINCT(user_id)')]);
1093 
        $selectCapsuleUser->from(CompanyMicrolearningCapsuleUserMapper::_TABLE);
2381 nelberth 1094 
        $selectCapsuleUser->where->equalTo('company_id', $company_id);
1095 
        $selectCapsuleUser->where->nest->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_UNLIMITED)->or->nest()
5973 anderson 1096 
            ->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_PAY_PERIOD)
1097 
            ->and->lessThanOrEqualTo(new Expression('DATE(paid_from)'), $date)
1098 
            ->and->greaterThanOrEqualTo(new Expression('DATE(paid_to)'), $date)->unnest()->unnest();
1099 
 
2381 nelberth 1100 
        //echo $select->getSqlString($this->adapter->platform); exit;
1101 
        $prototype = new User();
1102 
        $select = $this->sql->select();
5973 anderson 1103 
        $select->columns(['id', 'uuid', 'first_name', 'last_name', 'email', 'blocked']);
2381 nelberth 1104 
        $select->from(UserMapper::_TABLE);
1105 
        $select->where->in('id', $selectCapsuleUser);
1106 
        return $this->executeFetchAllObject($select, $prototype);
1107 
    }
1108 
 
1109 
    /**
1110 
     *
1111 
     * @param string $search
1 www 1112 
     * @return User[]
1113 
     */
1114 
    public function fetchAllSuggest($search)
1115 
    {
1116 
 
1117 
        $select = $this->sql->select();
1118 
        $select->from(self::_TABLE);
1119 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1120 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1121 
 
1122 
        if ($search) {
1 www 1123 
            $select->where->nest()
5973 anderson 1124 
                ->like('first_name', '%' . $search . '%')
1125 
                ->or->like('last_name', '%' . $search . '%')
1126 
                ->or->like('email', '%' . $search . '%')
1127 
                ->unnest();
1 www 1128 
        }
5973 anderson 1129 
 
1 www 1130 
        $select->order(['first_name', 'last_name']);
5973 anderson 1131 
 
1 www 1132 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1133 
 
1 www 1134 
        $prototype = new User();
5973 anderson 1135 
 
1 www 1136 
        return $this->executeFetchAllObject($select, $prototype);
1137 
    }
5973 anderson 1138 
 
3639 efrain 1139 
    /**
1140 
     *
1141 
     * @param int $network_id
1142 
     * @param string $search
1143 
     * @return User[]
1144 
     */
1145 
    public function fetchAllSuggestByNetworkIdAndSearch($network_id, $search)
1146 
    {
5973 anderson 1147 
 
3639 efrain 1148 
        $select = $this->sql->select();
1149 
        $select->from(self::_TABLE);
1150 
        $select->where->equalTo('network_id', $network_id);
1151 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1152 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1153 
 
1154 
        if ($search) {
3639 efrain 1155 
            $select->where->nest()
5984 anderson 1156 
                ->like('first_name', '%' . $search . '%')
5987 anderson 1157 
                ->or->like('last_name', '%' . $search . '%')
5993 anderson 1158 
                ->or->like(new Expression("CONCAT(first_name,' ',last_name)"), '%' . $search . '%')
5994 anderson 1159 
                ->or->like(new Expression("CONCAT(last_name,' ',first_name)"), '%' . $search . '%')
5985 anderson 1160 
                ->or->like('email', '%' . $search . '%')
5973 anderson 1161 
                ->unnest();
3639 efrain 1162 
        }
5973 anderson 1163 
 
3639 efrain 1164 
        $select->order(['first_name', 'last_name']);
5973 anderson 1165 
 
3639 efrain 1166 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1167 
 
3639 efrain 1168 
        $prototype = new User();
5973 anderson 1169 
 
3639 efrain 1170 
        return $this->executeFetchAllObject($select, $prototype);
1171 
    }
5973 anderson 1172 
 
1 www 1173 
    /**
1174 
     *
1175 
     * @param int $company_id
3639 efrain 1176 
     * @param int $network_id
1 www 1177 
     * @param string $search
1178 
     * @return User[]
1179 
     */
7159 efrain 1180 
    public function fetchAllByNetworkIdAndCompanyIdAndSearch($network_id, $company_id, $search)
1181 
    {
1182 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1183 
        $selectCompanyUsers->columns(['user_id']);
1184 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
1185 
        $selectCompanyUsers->where->in('status', [
1186 
            CompanyUser::STATUS_ACCEPTED,
1187 
            CompanyUser::STATUS_ADMIN_WILL_ADD,
1188 
 
1189 
        ]);
1190 
 
1191 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
1192 
 
1193 
        $select = $this->sql->select();
1194 
        $select->from(self::_TABLE);
1195 
        $select->where->equalTo('network_id', $network_id);
1196 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1197 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
1198 
 
1199 
 
1200 
        if ($search) {
1201 
            $select->where->nest()
1202 
            ->like('first_name', '%' . $search . '%')
1203 
            ->or->like('last_name', '%' . $search . '%')
1204 
            ->or->like('email', '%' . $search . '%')
1205 
            ->unnest();
1206 
        }
1207 
 
1208 
        $select->where->In('id', $selectCompanyUsers);
1209 
 
1210 
        $select->order(['first_name', 'last_name']);
1211 
 
1212 
       // echo $select->getSqlString($this->adapter->platform); exit;
1213 
 
1214 
        $prototype = new User();
1215 
 
1216 
        return $this->executeFetchAllObject($select, $prototype);
1217 
    }
1218 
 
1219 
 
1220 
    /**
1221 
     *
1222 
     * @param int $company_id
1223 
     * @param int $network_id
1224 
     * @param string $search
1225 
     * @return User[]
1226 
     */
3639 efrain 1227 
    public function fetchAllSuggestForInvitationByCompanyIdAndNetworkIdAndSearch($company_id, $network_id, $search)
1228 
    {
1229 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1230 
        $selectCompanyUsers->columns(['user_id']);
1231 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
1232 
        $selectCompanyUsers->where->in('status', [
1233 
            CompanyUser::STATUS_ACCEPTED,
1234 
            CompanyUser::STATUS_PENDING,
1235 
            CompanyUser::STATUS_SENT,
5973 anderson 1236 
 
3639 efrain 1237 
        ]);
5973 anderson 1238 
 
3639 efrain 1239 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1240 
 
3639 efrain 1241 
        $select = $this->sql->select();
1242 
        $select->from(self::_TABLE);
1243 
        $select->where->notIn('id', $selectCompanyUsers);
1244 
        $select->where->equalTo('network_id', $network_id);
1245 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1246 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1247 
 
1248 
        if ($search) {
3639 efrain 1249 
            $select->where->nest()
5973 anderson 1250 
                ->like('first_name', '%' . $search . '%')
1251 
                ->or->like('last_name', '%' . $search . '%')
1252 
                ->or->like('email', '%' . $search . '%')
1253 
                ->unnest();
3639 efrain 1254 
        }
5973 anderson 1255 
 
3639 efrain 1256 
        $select->order(['first_name', 'last_name']);
5973 anderson 1257 
 
3639 efrain 1258 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1259 
 
3639 efrain 1260 
        $prototype = new User();
5973 anderson 1261 
 
3639 efrain 1262 
        return $this->executeFetchAllObject($select, $prototype);
1263 
    }
5973 anderson 1264 
 
3639 efrain 1265 
    /**
1266 
     *
1267 
     * @param int $company_id
1268 
     * @param string $search
1269 
     * @return User[]
1270 
     */
1 www 1271 
    public function fetchAllSuggestForInvitationByCompanyId($company_id, $search)
1272 
    {
1273 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1274 
        $selectCompanyUsers->columns(['user_id']);
1275 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
5973 anderson 1276 
        $selectCompanyUsers->where->in('status', [
1 www 1277 
            CompanyUser::STATUS_ACCEPTED,
1278 
            CompanyUser::STATUS_PENDING,
1279 
            CompanyUser::STATUS_SENT,
1280 
 
1281 
        ]);
5973 anderson 1282 
 
1 www 1283 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1284 
 
1 www 1285 
        $select = $this->sql->select();
1286 
        $select->from(self::_TABLE);
1287 
        $select->where->notIn('id', $selectCompanyUsers);
1288 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1289 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1290 
 
1291 
        if ($search) {
1 www 1292 
            $select->where->nest()
5973 anderson 1293 
                ->like('first_name', '%' . $search . '%')
1294 
                ->or->like('last_name', '%' . $search . '%')
1295 
                ->or->like('email', '%' . $search . '%')
1296 
                ->unnest();
1 www 1297 
        }
5973 anderson 1298 
 
1 www 1299 
        $select->order(['first_name', 'last_name']);
5973 anderson 1300 
 
1301 
        // echo $select->getSqlString($this->adapter->platform); exit;
1302 
 
1303 
        $prototype = new User();
1304 
 
1 www 1305 
        return $this->executeFetchAllObject($select, $prototype);
1306 
    }
5973 anderson 1307 
 
1 www 1308 
    /**
1309 
     *
1310 
     * @param int $group_id
3639 efrain 1311 
     * @param int $network_id
1 www 1312 
     * @param string $search
1313 
     * @return User[]
1314 
     */
3639 efrain 1315 
    public function fetchAllSuggestForInvitationByGroupIdAndNetworkIdAndSearch($group_id, $network_id, $search)
1316 
    {
1317 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1318 
        $selectGroupMembers->columns(['user_id']);
1319 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1320 
        $selectGroupMembers->where->in('status', [
1321 
            CompanyUser::STATUS_ACCEPTED,
1322 
        ]);
5973 anderson 1323 
 
3639 efrain 1324 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1325 
 
3639 efrain 1326 
        $select = $this->sql->select();
1327 
        $select->from(self::_TABLE);
1328 
        $select->where->equalTo('network_id', $network_id);
1329 
        $select->where->notIn('id', $selectGroupMembers);
1330 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1331 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1332 
 
1333 
        if ($search) {
3639 efrain 1334 
            $select->where->nest()
5973 anderson 1335 
                ->like('first_name', '%' . $search . '%')
1336 
                ->or->like('last_name', '%' . $search . '%')
1337 
                ->or->like('email', '%' . $search . '%')
1338 
                ->unnest();
3639 efrain 1339 
        }
5973 anderson 1340 
 
3639 efrain 1341 
        $select->order(['first_name', 'last_name']);
5973 anderson 1342 
 
3639 efrain 1343 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1344 
 
3639 efrain 1345 
        $prototype = new User();
5973 anderson 1346 
 
3639 efrain 1347 
        return $this->executeFetchAllObject($select, $prototype);
1348 
    }
5973 anderson 1349 
 
3639 efrain 1350 
    /**
1351 
     *
1352 
     * @param int $group_id
1353 
     * @param string $search
1354 
     * @return User[]
1355 
     */
1 www 1356 
    public function fetchAllSuggestForInvitationByGroupId($group_id, $search)
1357 
    {
1358 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1359 
        $selectGroupMembers->columns(['user_id']);
1360 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1361 
        $selectGroupMembers->where->in('status', [
5973 anderson 1362 
            CompanyUser::STATUS_ACCEPTED,
1 www 1363 
        ]);
5973 anderson 1364 
 
1 www 1365 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1366 
 
1 www 1367 
        $select = $this->sql->select();
1368 
        $select->from(self::_TABLE);
1369 
        $select->where->notIn('id', $selectGroupMembers);
1370 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1371 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1372 
 
1373 
        if ($search) {
1 www 1374 
            $select->where->nest()
5973 anderson 1375 
                ->like('first_name', '%' . $search . '%')
1376 
                ->or->like('last_name', '%' . $search . '%')
1377 
                ->or->like('email', '%' . $search . '%')
1378 
                ->unnest();
1 www 1379 
        }
5973 anderson 1380 
 
1 www 1381 
        $select->order(['first_name', 'last_name']);
5973 anderson 1382 
 
1 www 1383 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1384 
 
1 www 1385 
        $prototype = new User();
5973 anderson 1386 
 
1 www 1387 
        return $this->executeFetchAllObject($select, $prototype);
1388 
    }
1665 nelberth 1389 
 
5973 anderson 1390 
 
1391 
 
1392 
    public function fetchAllSuggestForInvitationByHptgId($group_id, $company_id, $search)
1665 nelberth 1393 
    {
1394 
        $selectGroupMembers = $this->sql->select(HighPerformanceTeamsGroupsMembersMapper::_TABLE);
1395 
        $selectGroupMembers->columns(['user_id']);
1396 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1397 
        $selectGroupMembers->where->in('status', [
2082 nelberth 1398 
            HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED,
1399 
            HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN,
1400 
            HighPerformanceTeamsGroupsMembers::STATUS_INVITED,
1665 nelberth 1401 
        ]);
5973 anderson 1402 
 
1665 nelberth 1403 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1404 
 
1665 nelberth 1405 
        $select = $this->sql->select();
2092 nelberth 1406 
        $select->from(['u' => self::_TABLE]);
1407 
        $select->join(['cu' => CompanyUserMapper::_TABLE], 'cu.user_id = u.id', []);
2091 nelberth 1408 
        $select->where->notIn('u.id', $selectGroupMembers);
2090 nelberth 1409 
        $select->where->equalTo('u.status', User::STATUS_ACTIVE);
1410 
        $select->where->equalTo('u.email_verified', User::EMAIL_VERIFIED_YES);
1411 
        $select->where->equalTo('cu.company_id', $company_id);
1412 
 
5973 anderson 1413 
 
1414 
        if ($search) {
1665 nelberth 1415 
            $select->where->nest()
5973 anderson 1416 
                ->like('u.first_name', '%' . $search . '%')
1417 
                ->or->like('u.last_name', '%' . $search . '%')
1418 
                ->or->like('u.email', '%' . $search . '%')
1419 
                ->unnest();
1665 nelberth 1420 
        }
5973 anderson 1421 
 
2090 nelberth 1422 
        $select->order(['u.first_name', 'u.last_name']);
5973 anderson 1423 
 
1665 nelberth 1424 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1425 
 
1665 nelberth 1426 
        $prototype = new User();
5973 anderson 1427 
 
1665 nelberth 1428 
        return $this->executeFetchAllObject($select, $prototype);
1429 
    }
5973 anderson 1430 
 
1 www 1431 
    /**
1432 
     *
1433 
     * @param string $search
1434 
     * @param int $page
1435 
     * @param int $records_per_page
1436 
     * @param string $order_field
1437 
     * @param string $order_direction
1438 
     * @return Paginator
1439 
     */
5973 anderson 1440 
    public function fetchAllDataTable($search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 1441 
    {
1442 
        $prototype = new User();
1443 
        $select = $this->sql->select(self::_TABLE);
1444 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
5973 anderson 1445 
 
1446 
 
1447 
        if ($search) {
1 www 1448 
            $select->where->nest()
5973 anderson 1449 
                ->like('first_name', '%' . $search . '%')
1450 
                ->or->like('last_name', '%' . $search . '%')
1451 
                ->or->like('email', '%' . $search . '%')
1452 
                ->unnest();
1 www 1453 
        }
1454 
 
5973 anderson 1455 
 
1 www 1456 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1457 
 
1 www 1458 
        $hydrator   = new ObjectPropertyHydrator();
1459 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1460 
 
1 www 1461 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1462 
        $paginator = new Paginator($adapter);
1463 
        $paginator->setItemCountPerPage($records_per_page);
1464 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1465 
 
1466 
 
1 www 1467 
        return $paginator;
1468 
    }
5973 anderson 1469 
 
1 www 1470 
    /**
4398 efrain 1471 
     *
4751 efrain 1472 
     * @param int $network_id
1473 
     * @param string $search
1474 
     * @param int $page
1475 
     * @param int $records_per_page
1476 
     * @param string $order_field
1477 
     * @param string $order_direction
1478 
     * @return Paginator
1479 
     */
5973 anderson 1480 
    public function fetchAllDataTableByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4751 efrain 1481 
    {
1482 
        $prototype = new User();
1483 
        $select = $this->sql->select(self::_TABLE);
1484 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
4776 efrain 1485 
        $select->where->equalTo('network_id', $network_id);
1486 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
5973 anderson 1487 
 
1488 
 
1489 
        if ($search) {
4751 efrain 1490 
            $select->where->nest()
5973 anderson 1491 
                ->like('first_name', '%' . $search . '%')
1492 
                ->or->like('last_name', '%' . $search . '%')
1493 
                ->or->like('email', '%' . $search . '%')
1494 
                ->unnest();
4751 efrain 1495 
        }
5973 anderson 1496 
 
1497 
 
4751 efrain 1498 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1499 
 
4751 efrain 1500 
        $hydrator   = new ObjectPropertyHydrator();
1501 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1502 
 
4751 efrain 1503 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1504 
        $paginator = new Paginator($adapter);
1505 
        $paginator->setItemCountPerPage($records_per_page);
1506 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1507 
 
1508 
 
4751 efrain 1509 
        return $paginator;
1510 
    }
5973 anderson 1511 
 
1512 
 
1513 
 
1514 
 
4776 efrain 1515 
    /**
1516 
     *
1517 
     * @param int $network_id
1518 
     * @param string $search
1519 
     * @param int $page
1520 
     * @param int $records_per_page
1521 
     * @param string $order_field
1522 
     * @param string $order_direction
1523 
     * @return Paginator
1524 
     */
5973 anderson 1525 
    public function fetchAllDataTableRequestAccessPendingByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4776 efrain 1526 
    {
1527 
        $prototype = new User();
1528 
        $select = $this->sql->select(self::_TABLE);
1529 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
1530 
        $select->where->equalTo('network_id', $network_id);
1531 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_PENDING);
5973 anderson 1532 
 
1533 
        if ($search) {
4776 efrain 1534 
            $select->where->nest()
5973 anderson 1535 
                ->like('first_name', '%' . $search . '%')
1536 
                ->or->like('last_name', '%' . $search . '%')
1537 
                ->or->like('email', '%' . $search . '%')
1538 
                ->unnest();
4776 efrain 1539 
        }
5973 anderson 1540 
 
1541 
 
4776 efrain 1542 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1543 
 
4776 efrain 1544 
        $hydrator   = new ObjectPropertyHydrator();
1545 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1546 
 
4776 efrain 1547 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1548 
        $paginator = new Paginator($adapter);
1549 
        $paginator->setItemCountPerPage($records_per_page);
1550 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1551 
 
1552 
 
4776 efrain 1553 
        return $paginator;
1554 
    }
4751 efrain 1555 
 
5973 anderson 1556 
 
4751 efrain 1557 
    /**
1558 
     *
4398 efrain 1559 
     * @param int $id
1560 
     * @return boolean
1561 
     */
1562 
    public function markIsAdult($id)
1563 
    {
1564 
        $update = $this->sql->update(self::_TABLE);
1565 
        $update->set([
1566 
            'id_adult' => User::IS_ADULT_YES,
1567 
        ]);
1568 
        $update->where->equalTo('id', $id);
5973 anderson 1569 
 
4398 efrain 1570 
        return $this->executeUpdate($update);
1571 
    }
5973 anderson 1572 
 
4398 efrain 1573 
    /**
1574 
     *
1575 
     * @param int $id
1576 
     * @return boolean
1577 
     */
1578 
    public function markIsNotAdult($id)
1579 
    {
1580 
        $update = $this->sql->update(self::_TABLE);
1581 
        $update->set([
1582 
            'id_adult' => User::IS_ADULT_NO,
1583 
        ]);
1584 
        $update->where->equalTo('id', $id);
5973 anderson 1585 
 
4398 efrain 1586 
        return $this->executeUpdate($update);
1587 
    }
5973 anderson 1588 
 
4398 efrain 1589 
    /**
1 www 1590 
     *
1591 
     * @param int $id
1592 
     * @return boolean
1593 
     */
1594 
    public function updateChatOnlineStatus($id)
1595 
    {
1596 
        $update = $this->sql->update(self::_TABLE);
1597 
        $update->set([
5973 anderson 1598 
            'online' => 1,
1 www 1599 
        ]);
1600 
        $update->where->equalTo('id', $id);
5973 anderson 1601 
 
1 www 1602 
        return $this->executeUpdate($update);
1603 
    }
3086 efrain 1604 
 
5973 anderson 1605 
 
1606 
 
1 www 1607 
    /**
1608 
     *
1609 
     * @param int $id
1610 
     * @return boolean
1611 
     */
1612 
    public function updateLastActivity($id)
1613 
    {
1614 
        $update = $this->sql->update(self::_TABLE);
1615 
        $update->set([
1616 
            'last_activity_on' => new Expression('NOW()'),
3086 efrain 1617 
            'online' => 1,
1 www 1618 
        ]);
1619 
        $update->where->equalTo('id', $id);
5973 anderson 1620 
 
1 www 1621 
        return $this->executeUpdate($update);
1622 
    }
5973 anderson 1623 
 
1624 
 
1 www 1625 
    /**
1626 
     *
1627 
     * @param int $id
1628 
     * @return boolean
1629 
     */
1630 
    public function updateLastHeartBeat($id)
1631 
    {
1632 
        $update = $this->sql->update(self::_TABLE);
1633 
        $update->set([
1634 
            'last_heart_beat_at' => new Expression('NOW()'),
242 efrain 1635 
            'online' => 1,
1636 
 
1 www 1637 
        ]);
1638 
        $update->where->equalTo('id', $id);
5973 anderson 1639 
 
1 www 1640 
        return $this->executeUpdate($update);
1641 
    }
5973 anderson 1642 
 
242 efrain 1643 
    /**
1644 
     *
1645 
     * @param int $id
1646 
     * @return boolean
1647 
     */
1648 
    public function emailVerifyAndActive($id)
1649 
    {
1650 
        $update = $this->sql->update(self::_TABLE);
1651 
        $update->set([
1652 
            'email_verified' => User::EMAIL_VERIFIED_YES,
5973 anderson 1653 
            'status' => User::STATUS_ACTIVE,
242 efrain 1654 
        ]);
1655 
        $update->where->equalTo('id', $id);
5973 anderson 1656 
 
242 efrain 1657 
        return $this->executeUpdate($update);
1658 
    }
5973 anderson 1659 
 
1660 
 
630 efrain 1661 
    /**
1662 
     *
1663 
     * @param int $company_id
1664 
     * @return User[]
1665 
     */
1666 
    public function fetchAllVerifyAndActiveByCompanyId($company_id)
1667 
    {
1668 
        $select = $this->sql->select();
1669 
        $select->columns(['status', 'company_id']);
1670 
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
5973 anderson 1671 
        $select->join(['tb2' => self::_TABLE], 'tb1.user_id = tb2.id');
630 efrain 1672 
 
5973 anderson 1673 
 
1674 
 
630 efrain 1675 
        $select->where->equalTo('tb1.company_id', $company_id);
1676 
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
1677 
        $select->where->in('tb1.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
1678 
        $select->where->equalTo('tb2.email_verified', User::EMAIL_VERIFIED_YES);
1679 
        $select->where->equalTo('tb2.status', User::STATUS_ACTIVE);
5973 anderson 1680 
 
630 efrain 1681 
        $select->order('first_name', 'last_name', 'email');
1682 
 
1683 
        $prototype = User();
5973 anderson 1684 
 
630 efrain 1685 
        return $this->executeFetchAllObject($select, $prototype);
1686 
    }
1 www 1687 
}