Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 6749 | Ir a la última revisión | | 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 
     */
3639 efrain 1180 
    public function fetchAllSuggestForInvitationByCompanyIdAndNetworkIdAndSearch($company_id, $network_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_PENDING,
1188 
            CompanyUser::STATUS_SENT,
5973 anderson 1189 
 
3639 efrain 1190 
        ]);
5973 anderson 1191 
 
3639 efrain 1192 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1193 
 
3639 efrain 1194 
        $select = $this->sql->select();
1195 
        $select->from(self::_TABLE);
1196 
        $select->where->notIn('id', $selectCompanyUsers);
1197 
        $select->where->equalTo('network_id', $network_id);
1198 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1199 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1200 
 
1201 
        if ($search) {
3639 efrain 1202 
            $select->where->nest()
5973 anderson 1203 
                ->like('first_name', '%' . $search . '%')
1204 
                ->or->like('last_name', '%' . $search . '%')
1205 
                ->or->like('email', '%' . $search . '%')
1206 
                ->unnest();
3639 efrain 1207 
        }
5973 anderson 1208 
 
3639 efrain 1209 
        $select->order(['first_name', 'last_name']);
5973 anderson 1210 
 
3639 efrain 1211 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1212 
 
3639 efrain 1213 
        $prototype = new User();
5973 anderson 1214 
 
3639 efrain 1215 
        return $this->executeFetchAllObject($select, $prototype);
1216 
    }
5973 anderson 1217 
 
3639 efrain 1218 
    /**
1219 
     *
1220 
     * @param int $company_id
1221 
     * @param string $search
1222 
     * @return User[]
1223 
     */
1 www 1224 
    public function fetchAllSuggestForInvitationByCompanyId($company_id, $search)
1225 
    {
1226 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1227 
        $selectCompanyUsers->columns(['user_id']);
1228 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
5973 anderson 1229 
        $selectCompanyUsers->where->in('status', [
1 www 1230 
            CompanyUser::STATUS_ACCEPTED,
1231 
            CompanyUser::STATUS_PENDING,
1232 
            CompanyUser::STATUS_SENT,
1233 
 
1234 
        ]);
5973 anderson 1235 
 
1 www 1236 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1237 
 
1 www 1238 
        $select = $this->sql->select();
1239 
        $select->from(self::_TABLE);
1240 
        $select->where->notIn('id', $selectCompanyUsers);
1241 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1242 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1243 
 
1244 
        if ($search) {
1 www 1245 
            $select->where->nest()
5973 anderson 1246 
                ->like('first_name', '%' . $search . '%')
1247 
                ->or->like('last_name', '%' . $search . '%')
1248 
                ->or->like('email', '%' . $search . '%')
1249 
                ->unnest();
1 www 1250 
        }
5973 anderson 1251 
 
1 www 1252 
        $select->order(['first_name', 'last_name']);
5973 anderson 1253 
 
1254 
        // echo $select->getSqlString($this->adapter->platform); exit;
1255 
 
1256 
        $prototype = new User();
1257 
 
1 www 1258 
        return $this->executeFetchAllObject($select, $prototype);
1259 
    }
5973 anderson 1260 
 
1 www 1261 
    /**
1262 
     *
1263 
     * @param int $group_id
3639 efrain 1264 
     * @param int $network_id
1 www 1265 
     * @param string $search
1266 
     * @return User[]
1267 
     */
3639 efrain 1268 
    public function fetchAllSuggestForInvitationByGroupIdAndNetworkIdAndSearch($group_id, $network_id, $search)
1269 
    {
1270 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1271 
        $selectGroupMembers->columns(['user_id']);
1272 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1273 
        $selectGroupMembers->where->in('status', [
1274 
            CompanyUser::STATUS_ACCEPTED,
1275 
        ]);
5973 anderson 1276 
 
3639 efrain 1277 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1278 
 
3639 efrain 1279 
        $select = $this->sql->select();
1280 
        $select->from(self::_TABLE);
1281 
        $select->where->equalTo('network_id', $network_id);
1282 
        $select->where->notIn('id', $selectGroupMembers);
1283 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1284 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1285 
 
1286 
        if ($search) {
3639 efrain 1287 
            $select->where->nest()
5973 anderson 1288 
                ->like('first_name', '%' . $search . '%')
1289 
                ->or->like('last_name', '%' . $search . '%')
1290 
                ->or->like('email', '%' . $search . '%')
1291 
                ->unnest();
3639 efrain 1292 
        }
5973 anderson 1293 
 
3639 efrain 1294 
        $select->order(['first_name', 'last_name']);
5973 anderson 1295 
 
3639 efrain 1296 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1297 
 
3639 efrain 1298 
        $prototype = new User();
5973 anderson 1299 
 
3639 efrain 1300 
        return $this->executeFetchAllObject($select, $prototype);
1301 
    }
5973 anderson 1302 
 
3639 efrain 1303 
    /**
1304 
     *
1305 
     * @param int $group_id
1306 
     * @param string $search
1307 
     * @return User[]
1308 
     */
1 www 1309 
    public function fetchAllSuggestForInvitationByGroupId($group_id, $search)
1310 
    {
1311 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1312 
        $selectGroupMembers->columns(['user_id']);
1313 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1314 
        $selectGroupMembers->where->in('status', [
5973 anderson 1315 
            CompanyUser::STATUS_ACCEPTED,
1 www 1316 
        ]);
5973 anderson 1317 
 
1 www 1318 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1319 
 
1 www 1320 
        $select = $this->sql->select();
1321 
        $select->from(self::_TABLE);
1322 
        $select->where->notIn('id', $selectGroupMembers);
1323 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1324 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1325 
 
1326 
        if ($search) {
1 www 1327 
            $select->where->nest()
5973 anderson 1328 
                ->like('first_name', '%' . $search . '%')
1329 
                ->or->like('last_name', '%' . $search . '%')
1330 
                ->or->like('email', '%' . $search . '%')
1331 
                ->unnest();
1 www 1332 
        }
5973 anderson 1333 
 
1 www 1334 
        $select->order(['first_name', 'last_name']);
5973 anderson 1335 
 
1 www 1336 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1337 
 
1 www 1338 
        $prototype = new User();
5973 anderson 1339 
 
1 www 1340 
        return $this->executeFetchAllObject($select, $prototype);
1341 
    }
1665 nelberth 1342 
 
5973 anderson 1343 
 
1344 
 
1345 
    public function fetchAllSuggestForInvitationByHptgId($group_id, $company_id, $search)
1665 nelberth 1346 
    {
1347 
        $selectGroupMembers = $this->sql->select(HighPerformanceTeamsGroupsMembersMapper::_TABLE);
1348 
        $selectGroupMembers->columns(['user_id']);
1349 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1350 
        $selectGroupMembers->where->in('status', [
2082 nelberth 1351 
            HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED,
1352 
            HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN,
1353 
            HighPerformanceTeamsGroupsMembers::STATUS_INVITED,
1665 nelberth 1354 
        ]);
5973 anderson 1355 
 
1665 nelberth 1356 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1357 
 
1665 nelberth 1358 
        $select = $this->sql->select();
2092 nelberth 1359 
        $select->from(['u' => self::_TABLE]);
1360 
        $select->join(['cu' => CompanyUserMapper::_TABLE], 'cu.user_id = u.id', []);
2091 nelberth 1361 
        $select->where->notIn('u.id', $selectGroupMembers);
2090 nelberth 1362 
        $select->where->equalTo('u.status', User::STATUS_ACTIVE);
1363 
        $select->where->equalTo('u.email_verified', User::EMAIL_VERIFIED_YES);
1364 
        $select->where->equalTo('cu.company_id', $company_id);
1365 
 
5973 anderson 1366 
 
1367 
        if ($search) {
1665 nelberth 1368 
            $select->where->nest()
5973 anderson 1369 
                ->like('u.first_name', '%' . $search . '%')
1370 
                ->or->like('u.last_name', '%' . $search . '%')
1371 
                ->or->like('u.email', '%' . $search . '%')
1372 
                ->unnest();
1665 nelberth 1373 
        }
5973 anderson 1374 
 
2090 nelberth 1375 
        $select->order(['u.first_name', 'u.last_name']);
5973 anderson 1376 
 
1665 nelberth 1377 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1378 
 
1665 nelberth 1379 
        $prototype = new User();
5973 anderson 1380 
 
1665 nelberth 1381 
        return $this->executeFetchAllObject($select, $prototype);
1382 
    }
5973 anderson 1383 
 
1 www 1384 
    /**
1385 
     *
1386 
     * @param string $search
1387 
     * @param int $page
1388 
     * @param int $records_per_page
1389 
     * @param string $order_field
1390 
     * @param string $order_direction
1391 
     * @return Paginator
1392 
     */
5973 anderson 1393 
    public function fetchAllDataTable($search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 1394 
    {
1395 
        $prototype = new User();
1396 
        $select = $this->sql->select(self::_TABLE);
1397 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
5973 anderson 1398 
 
1399 
 
1400 
        if ($search) {
1 www 1401 
            $select->where->nest()
5973 anderson 1402 
                ->like('first_name', '%' . $search . '%')
1403 
                ->or->like('last_name', '%' . $search . '%')
1404 
                ->or->like('email', '%' . $search . '%')
1405 
                ->unnest();
1 www 1406 
        }
1407 
 
5973 anderson 1408 
 
1 www 1409 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1410 
 
1 www 1411 
        $hydrator   = new ObjectPropertyHydrator();
1412 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1413 
 
1 www 1414 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1415 
        $paginator = new Paginator($adapter);
1416 
        $paginator->setItemCountPerPage($records_per_page);
1417 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1418 
 
1419 
 
1 www 1420 
        return $paginator;
1421 
    }
5973 anderson 1422 
 
1 www 1423 
    /**
4398 efrain 1424 
     *
4751 efrain 1425 
     * @param int $network_id
1426 
     * @param string $search
1427 
     * @param int $page
1428 
     * @param int $records_per_page
1429 
     * @param string $order_field
1430 
     * @param string $order_direction
1431 
     * @return Paginator
1432 
     */
5973 anderson 1433 
    public function fetchAllDataTableByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4751 efrain 1434 
    {
1435 
        $prototype = new User();
1436 
        $select = $this->sql->select(self::_TABLE);
1437 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
4776 efrain 1438 
        $select->where->equalTo('network_id', $network_id);
1439 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
5973 anderson 1440 
 
1441 
 
1442 
        if ($search) {
4751 efrain 1443 
            $select->where->nest()
5973 anderson 1444 
                ->like('first_name', '%' . $search . '%')
1445 
                ->or->like('last_name', '%' . $search . '%')
1446 
                ->or->like('email', '%' . $search . '%')
1447 
                ->unnest();
4751 efrain 1448 
        }
5973 anderson 1449 
 
1450 
 
4751 efrain 1451 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1452 
 
4751 efrain 1453 
        $hydrator   = new ObjectPropertyHydrator();
1454 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1455 
 
4751 efrain 1456 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1457 
        $paginator = new Paginator($adapter);
1458 
        $paginator->setItemCountPerPage($records_per_page);
1459 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1460 
 
1461 
 
4751 efrain 1462 
        return $paginator;
1463 
    }
5973 anderson 1464 
 
1465 
 
1466 
 
1467 
 
4776 efrain 1468 
    /**
1469 
     *
1470 
     * @param int $network_id
1471 
     * @param string $search
1472 
     * @param int $page
1473 
     * @param int $records_per_page
1474 
     * @param string $order_field
1475 
     * @param string $order_direction
1476 
     * @return Paginator
1477 
     */
5973 anderson 1478 
    public function fetchAllDataTableRequestAccessPendingByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4776 efrain 1479 
    {
1480 
        $prototype = new User();
1481 
        $select = $this->sql->select(self::_TABLE);
1482 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
1483 
        $select->where->equalTo('network_id', $network_id);
1484 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_PENDING);
5973 anderson 1485 
 
1486 
        if ($search) {
4776 efrain 1487 
            $select->where->nest()
5973 anderson 1488 
                ->like('first_name', '%' . $search . '%')
1489 
                ->or->like('last_name', '%' . $search . '%')
1490 
                ->or->like('email', '%' . $search . '%')
1491 
                ->unnest();
4776 efrain 1492 
        }
5973 anderson 1493 
 
1494 
 
4776 efrain 1495 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1496 
 
4776 efrain 1497 
        $hydrator   = new ObjectPropertyHydrator();
1498 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1499 
 
4776 efrain 1500 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1501 
        $paginator = new Paginator($adapter);
1502 
        $paginator->setItemCountPerPage($records_per_page);
1503 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1504 
 
1505 
 
4776 efrain 1506 
        return $paginator;
1507 
    }
4751 efrain 1508 
 
5973 anderson 1509 
 
4751 efrain 1510 
    /**
1511 
     *
4398 efrain 1512 
     * @param int $id
1513 
     * @return boolean
1514 
     */
1515 
    public function markIsAdult($id)
1516 
    {
1517 
        $update = $this->sql->update(self::_TABLE);
1518 
        $update->set([
1519 
            'id_adult' => User::IS_ADULT_YES,
1520 
        ]);
1521 
        $update->where->equalTo('id', $id);
5973 anderson 1522 
 
4398 efrain 1523 
        return $this->executeUpdate($update);
1524 
    }
5973 anderson 1525 
 
4398 efrain 1526 
    /**
1527 
     *
1528 
     * @param int $id
1529 
     * @return boolean
1530 
     */
1531 
    public function markIsNotAdult($id)
1532 
    {
1533 
        $update = $this->sql->update(self::_TABLE);
1534 
        $update->set([
1535 
            'id_adult' => User::IS_ADULT_NO,
1536 
        ]);
1537 
        $update->where->equalTo('id', $id);
5973 anderson 1538 
 
4398 efrain 1539 
        return $this->executeUpdate($update);
1540 
    }
5973 anderson 1541 
 
4398 efrain 1542 
    /**
1 www 1543 
     *
1544 
     * @param int $id
1545 
     * @return boolean
1546 
     */
1547 
    public function updateChatOnlineStatus($id)
1548 
    {
1549 
        $update = $this->sql->update(self::_TABLE);
1550 
        $update->set([
5973 anderson 1551 
            'online' => 1,
1 www 1552 
        ]);
1553 
        $update->where->equalTo('id', $id);
5973 anderson 1554 
 
1 www 1555 
        return $this->executeUpdate($update);
1556 
    }
3086 efrain 1557 
 
5973 anderson 1558 
 
1559 
 
1 www 1560 
    /**
1561 
     *
1562 
     * @param int $id
1563 
     * @return boolean
1564 
     */
1565 
    public function updateLastActivity($id)
1566 
    {
1567 
        $update = $this->sql->update(self::_TABLE);
1568 
        $update->set([
1569 
            'last_activity_on' => new Expression('NOW()'),
3086 efrain 1570 
            'online' => 1,
1 www 1571 
        ]);
1572 
        $update->where->equalTo('id', $id);
5973 anderson 1573 
 
1 www 1574 
        return $this->executeUpdate($update);
1575 
    }
5973 anderson 1576 
 
1577 
 
1 www 1578 
    /**
1579 
     *
1580 
     * @param int $id
1581 
     * @return boolean
1582 
     */
1583 
    public function updateLastHeartBeat($id)
1584 
    {
1585 
        $update = $this->sql->update(self::_TABLE);
1586 
        $update->set([
1587 
            'last_heart_beat_at' => new Expression('NOW()'),
242 efrain 1588 
            'online' => 1,
1589 
 
1 www 1590 
        ]);
1591 
        $update->where->equalTo('id', $id);
5973 anderson 1592 
 
1 www 1593 
        return $this->executeUpdate($update);
1594 
    }
5973 anderson 1595 
 
242 efrain 1596 
    /**
1597 
     *
1598 
     * @param int $id
1599 
     * @return boolean
1600 
     */
1601 
    public function emailVerifyAndActive($id)
1602 
    {
1603 
        $update = $this->sql->update(self::_TABLE);
1604 
        $update->set([
1605 
            'email_verified' => User::EMAIL_VERIFIED_YES,
5973 anderson 1606 
            'status' => User::STATUS_ACTIVE,
242 efrain 1607 
        ]);
1608 
        $update->where->equalTo('id', $id);
5973 anderson 1609 
 
242 efrain 1610 
        return $this->executeUpdate($update);
1611 
    }
5973 anderson 1612 
 
1613 
 
630 efrain 1614 
    /**
1615 
     *
1616 
     * @param int $company_id
1617 
     * @return User[]
1618 
     */
1619 
    public function fetchAllVerifyAndActiveByCompanyId($company_id)
1620 
    {
1621 
        $select = $this->sql->select();
1622 
        $select->columns(['status', 'company_id']);
1623 
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
5973 anderson 1624 
        $select->join(['tb2' => self::_TABLE], 'tb1.user_id = tb2.id');
630 efrain 1625 
 
5973 anderson 1626 
 
1627 
 
630 efrain 1628 
        $select->where->equalTo('tb1.company_id', $company_id);
1629 
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
1630 
        $select->where->in('tb1.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
1631 
        $select->where->equalTo('tb2.email_verified', User::EMAIL_VERIFIED_YES);
1632 
        $select->where->equalTo('tb2.status', User::STATUS_ACTIVE);
5973 anderson 1633 
 
630 efrain 1634 
        $select->order('first_name', 'last_name', 'email');
1635 
 
1636 
        $prototype = User();
5973 anderson 1637 
 
630 efrain 1638 
        return $this->executeFetchAllObject($select, $prototype);
1639 
    }
1 www 1640 
}