Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 5994 | Rev 6023 | 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);
5973 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 . '%')
380 
            ->or->like('email', '%' . $search . '%')->unnest();
381 
 
382 
        if ($current_user) {
4857 efrain 383 
            $select->where->and->notEqualTo('id ', $current_user);
384 
        }
385 
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
5973 anderson 386 
 
4857 efrain 387 
        return $this->executeFetchAllObject($select, $prototype);
388 
    }
389 
 
5973 anderson 390 
 
6011 efrain 391 
 
392 
    /**
393 
     *
394 
     * @param int $network_id
395 
     * @param int[] $ids
396 
     * @param string $search
397 
     * @param int $current_user
398 
     * @param string $status
399 
     * @return User[]
400 
     */
401 
    public function fetchAllByNetworkIdAndIdsAndSearch($network_id, $ids, $search, $current_user = 0, $status = User::STATUS_ACTIVE)
402 
    {
403 
 
404 
        $prototype = new User();
405 
        $select = $this->sql->select(self::_TABLE);
406 
 
407 
 
408 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
409 
        $select->where->equalTo('network_id', $network_id);
410 
        $select->where->and->in('id', $ids);
411 
        $select->where->nest()
412 
        ->like('first_name', '%' . $search . '%')
413 
        ->or->like('last_name', '%' . $search . '%')
414 
        ->or->like('email', '%' . $search . '%')->unnest();
415 
 
416 
        if ($current_user) {
417 
            $select->where->and->notEqualTo('id ', $current_user);
418 
        }
419 
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
420 
 
421 
        return $this->executeFetchAllObject($select, $prototype);
422 
    }
5973 anderson 423 
 
424 
 
425 
 
426 
 
1 www 427 
    /**
428 
     *
429 
     * @return User[]
430 
     */
431 
    public function fetchAllByActives()
432 
    {
5973 anderson 433 
 
1 www 434 
        $prototype = new User();
435 
        $select = $this->sql->select(self::_TABLE);
5973 anderson 436 
 
437 
 
1 www 438 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
5973 anderson 439 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
440 
 
646 efrain 441 
        $select->order(['first_name DESC, last_name DESC, email_DESC']);
1 www 442 
 
5973 anderson 443 
 
1 www 444 
        return $this->executeFetchAllObject($select, $prototype);
445 
    }
5973 anderson 446 
 
1 www 447 
    /**
4857 efrain 448 
     *
449 
     * @param int $network_id
450 
     * @param int $current_user_id;
451 
     * @return int[]
452 
     */
453 
    public function fetchAllIdsByDefaultNetworkId($network_id, $current_user_id = 0)
454 
    {
455 
 
5973 anderson 456 
 
4857 efrain 457 
        $select = $this->sql->select(self::_TABLE);
458 
        $select->columns(['id']);
459 
        $select->where->equalTo('network_id', $network_id);
460 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
461 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
6011 efrain 462 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 463 
 
464 
        if ($current_user_id) {
4857 efrain 465 
            $select->where->notEqualTo('id', $current_user_id);
466 
        }
5973 anderson 467 
 
4857 efrain 468 
        $ids = [];
5973 anderson 469 
 
4857 efrain 470 
        $records = $this->executeFetchAllArray($select);
5973 anderson 471 
        foreach ($records as $record) {
4857 efrain 472 
            array_push($ids, $record['id']);
473 
        }
5973 anderson 474 
 
4857 efrain 475 
        return $ids;
476 
    }
5973 anderson 477 
 
4857 efrain 478 
    /**
479 
     *
480 
     * @param int $network_id
481 
     * @param string $search
482 
     * @param int $current_user_id;
483 
     * @return int[]
484 
     */
485 
    public function fetchAllIdsByDefaultNetworkIdAndSearch($network_id, $search, $current_user_id = 0)
486 
    {
5973 anderson 487 
 
488 
 
4857 efrain 489 
        $select = $this->sql->select(self::_TABLE);
490 
        $select->columns(['id']);
491 
        $select->where->equalTo('network_id', $network_id);
492 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
493 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
494 
        $select->where->nest()
5973 anderson 495 
            ->like('first_name', '%' . $search . '%')
496 
            ->or->like('last_name', '%' . $search . '%')
497 
            ->or->like('email', '%' . $search . '%')->unnest();
498 
 
499 
        if ($current_user_id) {
4857 efrain 500 
            $select->where->notEqualTo('id', $current_user_id);
501 
        }
5973 anderson 502 
 
4857 efrain 503 
        $ids = [];
5973 anderson 504 
 
4857 efrain 505 
        $records = $this->executeFetchAllArray($select);
5973 anderson 506 
        foreach ($records as $record) {
4857 efrain 507 
            array_push($ids, $record['id']);
508 
        }
5973 anderson 509 
 
4857 efrain 510 
        return $ids;
511 
    }
5973 anderson 512 
 
4857 efrain 513 
    /**
514 
     *
515 
     * @param int $network_id
516 
     * @param int $current_user_id;
517 
     * @return int[]
518 
     */
519 
    public function fetchAllIdsByNonDefaultNetworkId($network_id, $current_user_id = 0)
520 
    {
5973 anderson 521 
 
522 
 
4857 efrain 523 
        $select = $this->sql->select(self::_TABLE);
524 
        $select->columns(['id']);
525 
        $select->where->equalTo('network_id', $network_id);
526 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
527 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
6011 efrain 528 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
4857 efrain 529 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
5973 anderson 530 
 
531 
        if ($current_user_id) {
4857 efrain 532 
            $select->where->notEqualTo('id', $current_user_id);
533 
        }
5973 anderson 534 
 
4857 efrain 535 
        $ids = [];
5973 anderson 536 
 
4857 efrain 537 
        $records = $this->executeFetchAllArray($select);
5973 anderson 538 
        foreach ($records as $record) {
4857 efrain 539 
            array_push($ids, $record['id']);
540 
        }
5973 anderson 541 
 
4857 efrain 542 
        return $ids;
543 
    }
5973 anderson 544 
 
545 
 
4857 efrain 546 
    /**
547 
     *
548 
     * @param int $network_id
549 
     * @param string $search
550 
     * @param int $current_user_id;
551 
     * @return int[]
552 
     */
553 
    public function fetchAllIdsByNonDefaultNetworkIdAndSearch($network_id, $search, $current_user_id = 0)
554 
    {
5973 anderson 555 
 
556 
 
4857 efrain 557 
        $select = $this->sql->select(self::_TABLE);
558 
        $select->columns(['id']);
559 
        $select->where->equalTo('network_id', $network_id);
560 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
561 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
562 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
563 
        $select->where->nest()
5973 anderson 564 
            ->like('first_name', '%' . $search . '%')
565 
            ->or->like('last_name', '%' . $search . '%')
566 
            ->or->like('email', '%' . $search . '%')->unnest();
567 
 
568 
        if ($current_user_id) {
4857 efrain 569 
            $select->where->notEqualTo('id', $current_user_id);
570 
        }
5973 anderson 571 
 
572 
 
4857 efrain 573 
        $ids = [];
5973 anderson 574 
 
4857 efrain 575 
        $records = $this->executeFetchAllArray($select);
5973 anderson 576 
        foreach ($records as $record) {
4857 efrain 577 
            array_push($ids, $record['id']);
578 
        }
5973 anderson 579 
 
4857 efrain 580 
        return $ids;
581 
    }
5973 anderson 582 
 
583 
 
4857 efrain 584 
    /**
1 www 585 
     *
646 efrain 586 
     * @param int $company_id
5751 efrain 587 
     * @return User[]
646 efrain 588 
     */
589 
    public function fetchAllByCompanyId($company_id)
590 
    {
5973 anderson 591 
 
646 efrain 592 
        $prototype = new User();
593 
        $select = $this->sql->select();
594 
        $select->from(['tb1' => self::_TABLE]);
595 
        $select->join(['tb2' => CompanyUserMapper::_TABLE], 'tb1.id = tb2.user_id', []);
5973 anderson 596 
 
597 
 
646 efrain 598 
        $select->where->equalTo('tb2.company_id', $company_id);
599 
        $select->where->in('tb2.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
5973 anderson 600 
 
646 efrain 601 
        $select->where->equalTo('tb1.status', User::STATUS_ACTIVE);
5973 anderson 602 
        $select->where->equalTo('tb1.email_verified', User::EMAIL_VERIFIED_YES);
603 
 
646 efrain 604 
        $select->order(['first_name DESC, last_name DESC, email_DESC']);
5973 anderson 605 
 
606 
 
607 
 
646 efrain 608 
        return $this->executeFetchAllObject($select, $prototype);
609 
    }
5973 anderson 610 
 
646 efrain 611 
    /**
612 
     *
1 www 613 
     * @param int $user_id
3639 efrain 614 
     * @return boolean
615 
     */
616 
    public function leaveImpersonate($user_id)
617 
    {
618 
        $values = [
619 
            'impersonate_user_id' => new Expression('NULL')
620 
        ];
5973 anderson 621 
 
3639 efrain 622 
        $update = $this->sql->update(self::_TABLE);
623 
        $update->set($values);
624 
        $update->where->equalTo('id', $user_id);
5973 anderson 625 
 
3639 efrain 626 
        return $this->executeUpdate($update);
627 
    }
5973 anderson 628 
 
3639 efrain 629 
    /**
630 
     *
631 
     * @param int $user_id
632 
     * @param int $impersonate_user_id
633 
     * @return boolean
634 
     */
635 
    public function startImpersonate($user_id, $impersonate_user_id)
636 
    {
637 
        $values = [
638 
            'impersonate_user_id' => $impersonate_user_id
639 
        ];
5973 anderson 640 
 
3639 efrain 641 
        $update = $this->sql->update(self::_TABLE);
642 
        $update->set($values);
643 
        $update->where->equalTo('id', $user_id);
5973 anderson 644 
 
3639 efrain 645 
        return $this->executeUpdate($update);
646 
    }
5973 anderson 647 
 
3639 efrain 648 
    /**
649 
     *
650 
     * @param int $user_id
1 www 651 
     * @param string $password_reset_key
652 
     * @return boolean
653 
     */
654 
    public function updatePasswordResetKey($user_id, $password_reset_key)
655 
    {
656 
        $values = [
657 
            'password_reset_key' => $password_reset_key,
658 
            'password_generated_on' => date('Y-m-d H:i:s'),
659 
            'updated_on' => new Expression('NOW()')
660 
        ];
661 
 
662 
        $update = $this->sql->update(self::_TABLE);
663 
        $update->set($values);
664 
        $update->where->equalTo('id', $user_id);
5973 anderson 665 
 
1 www 666 
        return $this->executeUpdate($update);
667 
    }
5973 anderson 668 
 
669 
 
1979 efrain 670 
    /**
671 
     *
672 
     * @param int $user_id
673 
     * @param string $delete_account_key
674 
     * @return boolean
675 
     */
676 
    public function updateDeleteAccountKey($user_id, $delete_account_key)
677 
    {
678 
        $values = [
679 
            'delete_account_key' => $delete_account_key,
680 
            'delete_account_generated_on' => date('Y-m-d H:i:s'),
681 
            'updated_on' => new Expression('NOW()')
682 
        ];
5973 anderson 683 
 
1979 efrain 684 
        $update = $this->sql->update(self::_TABLE);
685 
        $update->set($values);
686 
        $update->where->equalTo('id', $user_id);
5973 anderson 687 
 
1979 efrain 688 
        return $this->executeUpdate($update);
689 
    }
1 www 690 
 
5973 anderson 691 
 
692 
 
1 www 693 
    /**
694 
     *
695 
     * @param User $user
696 
     * @param string $password_hash
697 
     * @return boolean
698 
     */
699 
    public function updatePassword($user, $password_hash)
700 
    {
701 
        $values = [
702 
            'password'              => $password_hash,
703 
            'password_reset_key'    => '',
704 
            'password_updated_on'   => date('Y-m-d H:i:s'),
705 
            'login_attempt'         => 0,
706 
            'blocked'               => User::BLOCKED_NO,
707 
            'updated_on'            => new Expression('NOW()')
708 
        ];
5973 anderson 709 
 
1 www 710 
        $update = $this->sql->update(self::_TABLE);
711 
        $update->set($values);
712 
        $update->where->equalTo('id', $user->id);
5973 anderson 713 
 
1 www 714 
        return $this->executeUpdate($update);
715 
    }
5973 anderson 716 
 
717 
 
718 
 
1 www 719 
    /**
720 
     *
721 
     * @param User $user
5935 efrain 722 
     * @param int $usertype_id
1 www 723 
     * @return boolean
724 
     */
5935 efrain 725 
    public function updateUserTypeId($user, $usertype_id)
726 
    {
727 
        $values = [
728 
            'usertype_id'   => $usertype_id,
729 
            'updated_on'    => new Expression('NOW()')
730 
        ];
5973 anderson 731 
 
5935 efrain 732 
        $update = $this->sql->update(self::_TABLE);
733 
        $update->set($values);
734 
        $update->where->equalTo('id', $user->id);
5973 anderson 735 
 
5935 efrain 736 
        return $this->executeUpdate($update);
737 
    }
5973 anderson 738 
 
739 
 
5935 efrain 740 
    /**
741 
     *
742 
     * @param User $user
743 
     * @return boolean
744 
     */
1 www 745 
    public function unblock($user)
746 
    {
747 
        $values = [
748 
            'login_attempt'         => 0,
749 
            'blocked'               => User::BLOCKED_NO,
750 
            'updated_on'            => new Expression('NOW()')
751 
        ];
5973 anderson 752 
 
1 www 753 
        $update = $this->sql->update(self::_TABLE);
754 
        $update->set($values);
755 
        $update->where->equalTo('id', $user->id);
5973 anderson 756 
 
1 www 757 
        return $this->executeUpdate($update);
758 
    }
5973 anderson 759 
 
760 
 
761 
 
762 
 
1 www 763 
    /**
764 
     *
765 
     * @param User $user
766 
     * @param string $one_time_password
767 
     * @return boolean
768 
     */
769 
    public function updateOneTimePassword($user, $one_time_password)
770 
    {
771 
        $values = [
772 
            'one_time_password' => $one_time_password,
773 
            'updated_on'        => new Expression('NOW()')
774 
        ];
5973 anderson 775 
 
1 www 776 
        $update = $this->sql->update(self::_TABLE);
777 
        $update->set($values);
778 
        $update->where->equalTo('id', $user->id);
5973 anderson 779 
 
1 www 780 
        return $this->executeUpdate($update);
781 
    }
5973 anderson 782 
 
783 
 
1 www 784 
    /**
785 
     *
786 
     * @param User $user
787 
     * @return boolean
788 
     */
789 
    public function update($user)
790 
    {
791 
        $hydrator = new ObjectPropertyHydrator();
792 
        $values = $hydrator->extract($user);
1979 efrain 793 
        //$values = $this->removeEmpty($values);
794 
 
795 
 
796 
        unset($values['added_on']);
5973 anderson 797 
        $values['updated_on'] = new Expression('NOW()');
798 
 
1 www 799 
        $update = $this->sql->update(self::_TABLE);
800 
        $update->set($values);
5973 anderson 801 
        $update->where->equalTo('id', $user->id);
802 
 
1979 efrain 803 
        //echo $update->getSqlString($this->adapter->platform); exit;
5973 anderson 804 
 
1 www 805 
        return $this->executeUpdate($update);
806 
    }
5973 anderson 807 
 
1 www 808 
    /**
809 
     *
810 
     * @param User $user
811 
     * @return boolean
812 
     */
813 
    public function updatePrivacy($user)
814 
    {
815 
        $values = [
816 
            'show_in_search' => $user->show_in_search,
817 
            'updated_on' => new Expression('NOW()')
818 
        ];
5973 anderson 819 
 
1 www 820 
        $update = $this->sql->update(self::_TABLE);
821 
        $update->set($values);
5973 anderson 822 
        $update->where->equalTo('id', $user->id);
823 
 
1 www 824 
        return $this->executeUpdate($update);
825 
    }
5973 anderson 826 
 
1 www 827 
    /**
828 
     *
829 
     * @param User $user
830 
     * @return boolean
831 
     */
832 
    public function updateBasic($user)
833 
    {
834 
        $values = [
835 
            'first_name' => $user->first_name,
836 
            'last_name' => $user->last_name,
837 
            'phone' => $user->phone,
838 
            'gender' => $user->gender,
4113 efrain 839 
            'timezone' => $user->timezone,
4416 efrain 840 
            'is_adult' => $user->is_adult,
1 www 841 
            'updated_on' => new Expression('NOW()')
842 
        ];
5973 anderson 843 
 
1 www 844 
        $update = $this->sql->update(self::_TABLE);
845 
        $update->set($values);
5973 anderson 846 
        $update->where->equalTo('id', $user->id);
847 
 
1 www 848 
        return $this->executeUpdate($update);
849 
    }
5973 anderson 850 
 
851 
 
1 www 852 
    /**
853 
     *
854 
     * @param User $user
855 
     * @return boolean
856 
     */
857 
    public function updateImage($user)
858 
    {
859 
        $values = [
860 
            'image' => $user->image,
861 
            'updated_on' => new Expression('NOW()')
862 
        ];
5973 anderson 863 
 
1 www 864 
        $update = $this->sql->update(self::_TABLE);
865 
        $update->set($values);
5973 anderson 866 
        $update->where->equalTo('id', $user->id);
867 
 
1 www 868 
        return $this->executeUpdate($update);
869 
    }
5973 anderson 870 
 
1 www 871 
    /**
872 
     *
873 
     * @param User $user
874 
     * @return boolean
875 
     */
876 
    public function updateLocation($user)
877 
    {
878 
        $values = [
879 
            'location_id' => $user->location_id,
880 
            'updated_on' => new Expression('NOW()')
881 
        ];
5973 anderson 882 
 
1 www 883 
        $update = $this->sql->update(self::_TABLE);
884 
        $update->set($values);
5973 anderson 885 
        $update->where->equalTo('id', $user->id);
886 
 
1 www 887 
        return $this->executeUpdate($update);
888 
    }
5973 anderson 889 
 
1 www 890 
    /**
891 
     *
892 
     * @param int $user_id
893 
     * @return boolean
894 
     */
895 
    public function activateAccount($user_id)
896 
    {
897 
        $values = [
898 
            'email_verified'    => User::EMAIL_VERIFIED_YES,
899 
            'status'            => User::STATUS_ACTIVE,
900 
            'activation_key'    => '',
901 
            'updated_on' => new Expression('NOW()')
902 
        ];
5973 anderson 903 
 
1 www 904 
        $update = $this->sql->update(self::_TABLE);
905 
        $update->set($values);
906 
        $update->where->equalTo('id', $user_id);
5973 anderson 907 
 
1 www 908 
        return $this->executeUpdate($update);
909 
    }
5973 anderson 910 
 
1 www 911 
    /**
912 
     *
913 
     * @param User $user
914 
     * @return boolean
915 
     */
916 
    public function insert($user)
917 
    {
5973 anderson 918 
 
1 www 919 
        $hydrator = new ObjectPropertyHydrator();
920 
        $values = $hydrator->extract($user);
921 
        $values = $this->removeEmpty($values);
5973 anderson 922 
 
1 www 923 
        $insert = $this->sql->insert(self::_TABLE);
924 
        $insert->values($values);
5973 anderson 925 
 
1 www 926 
        $response = $this->executeInsert($insert);
5973 anderson 927 
        if ($response) {
1 www 928 
            $user->id = $this->lastInsertId;
929 
        }
5973 anderson 930 
 
1 www 931 
        return $response;
932 
    }
5973 anderson 933 
 
934 
 
1 www 935 
    /**
936 
     *
937 
     * @return boolean
938 
     */
939 
    public function truncate()
940 
    {
941 
        $sql = sprintf('TRUNCATE TABLE `%s` ', self::_TABLE);
942 
        return $this->executeSentenceWithParameters($sql);
943 
    }
5973 anderson 944 
 
1 www 945 
    /**
946 
     *
947 
     * @param int $company_id
948 
     * @param string $status
949 
     * @param string $search
950 
     * @param int $page
951 
     * @param int $records_per_page
952 
     * @param string $order_field
953 
     * @param string $order_direction
954 
     * @return Paginator
955 
     */
5973 anderson 956 
    public function fetchAllDataTableByCompanyId($company_id, $status = '', $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 957 
    {
5973 anderson 958 
        $select = $this->sql->select();
1 www 959 
        $select->columns(['status', 'backend', 'creator']);
960 
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
5973 anderson 961 
        $select->join(['tb2' => self::_TABLE], 'tb1.user_id = tb2.id', [
1 www 962 
            'id', 'uuid', 'first_name', 'last_name', 'email', 'last_activity_on', 'image',
963 
            'blocked', 'login_attempt', 'email_verified'
5973 anderson 964 
 
1 www 965 
        ]);
5973 anderson 966 
 
1 www 967 
        $select->where->equalTo('tb1.company_id', $company_id);
968 
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
5973 anderson 969 
 
970 
        if ($status) {
971 
            $select->where->equalTo('tb1.status', $status);
972 
        }
973 
 
974 
        if ($search) {
1 www 975 
            $select->where->nest()
5973 anderson 976 
                ->like('first_name', '%' . $search . '%')
977 
                ->or->like('last_name', '%' . $search . '%')
978 
                ->or->like('email', '%' . $search . '%')
979 
                ->unnest();
1 www 980 
        }
5973 anderson 981 
 
982 
 
1 www 983 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 984 
 
1 www 985 
        $hydrator   = new ArraySerializableHydrator();
986 
        $resultset  = new HydratingResultSet($hydrator);
5973 anderson 987 
 
1 www 988 
        $adapter = new DbSelect($select, $this->sql, $resultset);
989 
        $paginator = new Paginator($adapter);
990 
        $paginator->setItemCountPerPage($records_per_page);
991 
        $paginator->setCurrentPageNumber($page);
5973 anderson 992 
 
993 
 
1 www 994 
        return $paginator;
995 
    }
5973 anderson 996 
 
997 
 
1 www 998 
    /**
999 
     *
1000 
     * @param int $company_id
1001 
     * @param string $search
1002 
     * @param int $page
1003 
     * @param int $records_per_page
1004 
     * @param string $order_field
1005 
     * @param string $order_direction
1006 
     * @return Paginator
1007 
     */
5973 anderson 1008 
    public function fetchAllDataTableStudensByCompanyId($company_id,  $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 1009 
    {
1010 
        $date = date('Y-m-d');
5973 anderson 1011 
 
1 www 1012 
        $selectCapsuleUser = $this->getSql()->select();
5973 anderson 1013 
        $selectCapsuleUser->columns(['user_id' => new Expression('DISTINCT(user_id)')]);
1014 
        $selectCapsuleUser->from(CompanyMicrolearningCapsuleUserMapper::_TABLE);
1 www 1015 
        $selectCapsuleUser->where->equalTo('company_id', $company_id);
1016 
        $selectCapsuleUser->where->nest->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_UNLIMITED)->or->nest()
5973 anderson 1017 
            ->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_PAY_PERIOD)
1018 
            ->and->lessThanOrEqualTo(new Expression('DATE(paid_from)'), $date)
1019 
            ->and->greaterThanOrEqualTo(new Expression('DATE(paid_to)'), $date)->unnest()->unnest();
1020 
 
1 www 1021 
        //echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1022 
 
1 www 1023 
        $select = $this->sql->select();
5973 anderson 1024 
        $select->columns(['id', 'uuid', 'first_name', 'last_name', 'email', 'blocked']);
1 www 1025 
        $select->from(UserMapper::_TABLE);
1026 
        $select->where->in('id', $selectCapsuleUser);
1027 
 
5973 anderson 1028 
 
1029 
        if ($search) {
1 www 1030 
            $select->where->nest()
5973 anderson 1031 
                ->like('first_name', '%' . $search . '%')
1032 
                ->or->like('last_name', '%' . $search . '%')
1033 
                ->or->like('email', '%' . $search . '%')
1034 
                ->unnest();
1 www 1035 
        }
5973 anderson 1036 
 
1037 
 
1 www 1038 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1039 
 
1 www 1040 
        $hydrator   = new ArraySerializableHydrator();
1041 
        $resultset  = new HydratingResultSet($hydrator);
5973 anderson 1042 
 
1 www 1043 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1044 
        $paginator = new Paginator($adapter);
1045 
        $paginator->setItemCountPerPage($records_per_page);
1046 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1047 
 
1048 
 
1 www 1049 
        return $paginator;
1050 
    }
2381 nelberth 1051 
 
5973 anderson 1052 
 
1 www 1053 
    /**
1054 
     *
2381 nelberth 1055 
     * @param int $company_id
1 www 1056 
     * @param string $search
2381 nelberth 1057 
     * @param int $page
1058 
     * @param int $records_per_page
1059 
     * @param string $order_field
1060 
     * @param string $order_direction
1061 
     * @return Paginator
1062 
     */
1063 
    public function fetchAllStudensByCompanyId($company_id)
1064 
    {
5973 anderson 1065 
 
2381 nelberth 1066 
        $date = date('Y-m-d');
5973 anderson 1067 
 
2381 nelberth 1068 
        $selectCapsuleUser = $this->getSql()->select();
5973 anderson 1069 
        $selectCapsuleUser->columns(['user_id' => new Expression('DISTINCT(user_id)')]);
1070 
        $selectCapsuleUser->from(CompanyMicrolearningCapsuleUserMapper::_TABLE);
2381 nelberth 1071 
        $selectCapsuleUser->where->equalTo('company_id', $company_id);
1072 
        $selectCapsuleUser->where->nest->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_UNLIMITED)->or->nest()
5973 anderson 1073 
            ->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_PAY_PERIOD)
1074 
            ->and->lessThanOrEqualTo(new Expression('DATE(paid_from)'), $date)
1075 
            ->and->greaterThanOrEqualTo(new Expression('DATE(paid_to)'), $date)->unnest()->unnest();
1076 
 
2381 nelberth 1077 
        //echo $select->getSqlString($this->adapter->platform); exit;
1078 
        $prototype = new User();
1079 
        $select = $this->sql->select();
5973 anderson 1080 
        $select->columns(['id', 'uuid', 'first_name', 'last_name', 'email', 'blocked']);
2381 nelberth 1081 
        $select->from(UserMapper::_TABLE);
1082 
        $select->where->in('id', $selectCapsuleUser);
1083 
        return $this->executeFetchAllObject($select, $prototype);
1084 
    }
1085 
 
1086 
    /**
1087 
     *
1088 
     * @param string $search
1 www 1089 
     * @return User[]
1090 
     */
1091 
    public function fetchAllSuggest($search)
1092 
    {
1093 
 
1094 
        $select = $this->sql->select();
1095 
        $select->from(self::_TABLE);
1096 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1097 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1098 
 
1099 
        if ($search) {
1 www 1100 
            $select->where->nest()
5973 anderson 1101 
                ->like('first_name', '%' . $search . '%')
1102 
                ->or->like('last_name', '%' . $search . '%')
1103 
                ->or->like('email', '%' . $search . '%')
1104 
                ->unnest();
1 www 1105 
        }
5973 anderson 1106 
 
1 www 1107 
        $select->order(['first_name', 'last_name']);
5973 anderson 1108 
 
1 www 1109 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1110 
 
1 www 1111 
        $prototype = new User();
5973 anderson 1112 
 
1 www 1113 
        return $this->executeFetchAllObject($select, $prototype);
1114 
    }
5973 anderson 1115 
 
3639 efrain 1116 
    /**
1117 
     *
1118 
     * @param int $network_id
1119 
     * @param string $search
1120 
     * @return User[]
1121 
     */
1122 
    public function fetchAllSuggestByNetworkIdAndSearch($network_id, $search)
1123 
    {
5973 anderson 1124 
 
3639 efrain 1125 
        $select = $this->sql->select();
1126 
        $select->from(self::_TABLE);
1127 
        $select->where->equalTo('network_id', $network_id);
1128 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1129 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1130 
 
1131 
        if ($search) {
3639 efrain 1132 
            $select->where->nest()
5984 anderson 1133 
                ->like('first_name', '%' . $search . '%')
5987 anderson 1134 
                ->or->like('last_name', '%' . $search . '%')
5993 anderson 1135 
                ->or->like(new Expression("CONCAT(first_name,' ',last_name)"), '%' . $search . '%')
5994 anderson 1136 
                ->or->like(new Expression("CONCAT(last_name,' ',first_name)"), '%' . $search . '%')
5985 anderson 1137 
                ->or->like('email', '%' . $search . '%')
5973 anderson 1138 
                ->unnest();
3639 efrain 1139 
        }
5973 anderson 1140 
 
3639 efrain 1141 
        $select->order(['first_name', 'last_name']);
5973 anderson 1142 
 
3639 efrain 1143 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1144 
 
3639 efrain 1145 
        $prototype = new User();
5973 anderson 1146 
 
3639 efrain 1147 
        return $this->executeFetchAllObject($select, $prototype);
1148 
    }
5973 anderson 1149 
 
1 www 1150 
    /**
1151 
     *
1152 
     * @param int $company_id
3639 efrain 1153 
     * @param int $network_id
1 www 1154 
     * @param string $search
1155 
     * @return User[]
1156 
     */
3639 efrain 1157 
    public function fetchAllSuggestForInvitationByCompanyIdAndNetworkIdAndSearch($company_id, $network_id, $search)
1158 
    {
1159 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1160 
        $selectCompanyUsers->columns(['user_id']);
1161 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
1162 
        $selectCompanyUsers->where->in('status', [
1163 
            CompanyUser::STATUS_ACCEPTED,
1164 
            CompanyUser::STATUS_PENDING,
1165 
            CompanyUser::STATUS_SENT,
5973 anderson 1166 
 
3639 efrain 1167 
        ]);
5973 anderson 1168 
 
3639 efrain 1169 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1170 
 
3639 efrain 1171 
        $select = $this->sql->select();
1172 
        $select->from(self::_TABLE);
1173 
        $select->where->notIn('id', $selectCompanyUsers);
1174 
        $select->where->equalTo('network_id', $network_id);
1175 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1176 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1177 
 
1178 
        if ($search) {
3639 efrain 1179 
            $select->where->nest()
5973 anderson 1180 
                ->like('first_name', '%' . $search . '%')
1181 
                ->or->like('last_name', '%' . $search . '%')
1182 
                ->or->like('email', '%' . $search . '%')
1183 
                ->unnest();
3639 efrain 1184 
        }
5973 anderson 1185 
 
3639 efrain 1186 
        $select->order(['first_name', 'last_name']);
5973 anderson 1187 
 
3639 efrain 1188 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1189 
 
3639 efrain 1190 
        $prototype = new User();
5973 anderson 1191 
 
3639 efrain 1192 
        return $this->executeFetchAllObject($select, $prototype);
1193 
    }
5973 anderson 1194 
 
3639 efrain 1195 
    /**
1196 
     *
1197 
     * @param int $company_id
1198 
     * @param string $search
1199 
     * @return User[]
1200 
     */
1 www 1201 
    public function fetchAllSuggestForInvitationByCompanyId($company_id, $search)
1202 
    {
1203 
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
1204 
        $selectCompanyUsers->columns(['user_id']);
1205 
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
5973 anderson 1206 
        $selectCompanyUsers->where->in('status', [
1 www 1207 
            CompanyUser::STATUS_ACCEPTED,
1208 
            CompanyUser::STATUS_PENDING,
1209 
            CompanyUser::STATUS_SENT,
1210 
 
1211 
        ]);
5973 anderson 1212 
 
1 www 1213 
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
5973 anderson 1214 
 
1 www 1215 
        $select = $this->sql->select();
1216 
        $select->from(self::_TABLE);
1217 
        $select->where->notIn('id', $selectCompanyUsers);
1218 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1219 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1220 
 
1221 
        if ($search) {
1 www 1222 
            $select->where->nest()
5973 anderson 1223 
                ->like('first_name', '%' . $search . '%')
1224 
                ->or->like('last_name', '%' . $search . '%')
1225 
                ->or->like('email', '%' . $search . '%')
1226 
                ->unnest();
1 www 1227 
        }
5973 anderson 1228 
 
1 www 1229 
        $select->order(['first_name', 'last_name']);
5973 anderson 1230 
 
1231 
        // echo $select->getSqlString($this->adapter->platform); exit;
1232 
 
1233 
        $prototype = new User();
1234 
 
1 www 1235 
        return $this->executeFetchAllObject($select, $prototype);
1236 
    }
5973 anderson 1237 
 
1 www 1238 
    /**
1239 
     *
1240 
     * @param int $group_id
3639 efrain 1241 
     * @param int $network_id
1 www 1242 
     * @param string $search
1243 
     * @return User[]
1244 
     */
3639 efrain 1245 
    public function fetchAllSuggestForInvitationByGroupIdAndNetworkIdAndSearch($group_id, $network_id, $search)
1246 
    {
1247 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1248 
        $selectGroupMembers->columns(['user_id']);
1249 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1250 
        $selectGroupMembers->where->in('status', [
1251 
            CompanyUser::STATUS_ACCEPTED,
1252 
        ]);
5973 anderson 1253 
 
3639 efrain 1254 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1255 
 
3639 efrain 1256 
        $select = $this->sql->select();
1257 
        $select->from(self::_TABLE);
1258 
        $select->where->equalTo('network_id', $network_id);
1259 
        $select->where->notIn('id', $selectGroupMembers);
1260 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1261 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1262 
 
1263 
        if ($search) {
3639 efrain 1264 
            $select->where->nest()
5973 anderson 1265 
                ->like('first_name', '%' . $search . '%')
1266 
                ->or->like('last_name', '%' . $search . '%')
1267 
                ->or->like('email', '%' . $search . '%')
1268 
                ->unnest();
3639 efrain 1269 
        }
5973 anderson 1270 
 
3639 efrain 1271 
        $select->order(['first_name', 'last_name']);
5973 anderson 1272 
 
3639 efrain 1273 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1274 
 
3639 efrain 1275 
        $prototype = new User();
5973 anderson 1276 
 
3639 efrain 1277 
        return $this->executeFetchAllObject($select, $prototype);
1278 
    }
5973 anderson 1279 
 
3639 efrain 1280 
    /**
1281 
     *
1282 
     * @param int $group_id
1283 
     * @param string $search
1284 
     * @return User[]
1285 
     */
1 www 1286 
    public function fetchAllSuggestForInvitationByGroupId($group_id, $search)
1287 
    {
1288 
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
1289 
        $selectGroupMembers->columns(['user_id']);
1290 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1291 
        $selectGroupMembers->where->in('status', [
5973 anderson 1292 
            CompanyUser::STATUS_ACCEPTED,
1 www 1293 
        ]);
5973 anderson 1294 
 
1 www 1295 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1296 
 
1 www 1297 
        $select = $this->sql->select();
1298 
        $select->from(self::_TABLE);
1299 
        $select->where->notIn('id', $selectGroupMembers);
1300 
        $select->where->equalTo('status', User::STATUS_ACTIVE);
1301 
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
5973 anderson 1302 
 
1303 
        if ($search) {
1 www 1304 
            $select->where->nest()
5973 anderson 1305 
                ->like('first_name', '%' . $search . '%')
1306 
                ->or->like('last_name', '%' . $search . '%')
1307 
                ->or->like('email', '%' . $search . '%')
1308 
                ->unnest();
1 www 1309 
        }
5973 anderson 1310 
 
1 www 1311 
        $select->order(['first_name', 'last_name']);
5973 anderson 1312 
 
1 www 1313 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1314 
 
1 www 1315 
        $prototype = new User();
5973 anderson 1316 
 
1 www 1317 
        return $this->executeFetchAllObject($select, $prototype);
1318 
    }
1665 nelberth 1319 
 
5973 anderson 1320 
 
1321 
 
1322 
    public function fetchAllSuggestForInvitationByHptgId($group_id, $company_id, $search)
1665 nelberth 1323 
    {
1324 
        $selectGroupMembers = $this->sql->select(HighPerformanceTeamsGroupsMembersMapper::_TABLE);
1325 
        $selectGroupMembers->columns(['user_id']);
1326 
        $selectGroupMembers->where->equalTo('group_id', $group_id);
1327 
        $selectGroupMembers->where->in('status', [
2082 nelberth 1328 
            HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED,
1329 
            HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN,
1330 
            HighPerformanceTeamsGroupsMembers::STATUS_INVITED,
1665 nelberth 1331 
        ]);
5973 anderson 1332 
 
1665 nelberth 1333 
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
5973 anderson 1334 
 
1665 nelberth 1335 
        $select = $this->sql->select();
2092 nelberth 1336 
        $select->from(['u' => self::_TABLE]);
1337 
        $select->join(['cu' => CompanyUserMapper::_TABLE], 'cu.user_id = u.id', []);
2091 nelberth 1338 
        $select->where->notIn('u.id', $selectGroupMembers);
2090 nelberth 1339 
        $select->where->equalTo('u.status', User::STATUS_ACTIVE);
1340 
        $select->where->equalTo('u.email_verified', User::EMAIL_VERIFIED_YES);
1341 
        $select->where->equalTo('cu.company_id', $company_id);
1342 
 
5973 anderson 1343 
 
1344 
        if ($search) {
1665 nelberth 1345 
            $select->where->nest()
5973 anderson 1346 
                ->like('u.first_name', '%' . $search . '%')
1347 
                ->or->like('u.last_name', '%' . $search . '%')
1348 
                ->or->like('u.email', '%' . $search . '%')
1349 
                ->unnest();
1665 nelberth 1350 
        }
5973 anderson 1351 
 
2090 nelberth 1352 
        $select->order(['u.first_name', 'u.last_name']);
5973 anderson 1353 
 
1665 nelberth 1354 
        // echo $select->getSqlString($this->adapter->platform); exit;
5973 anderson 1355 
 
1665 nelberth 1356 
        $prototype = new User();
5973 anderson 1357 
 
1665 nelberth 1358 
        return $this->executeFetchAllObject($select, $prototype);
1359 
    }
5973 anderson 1360 
 
1 www 1361 
    /**
1362 
     *
1363 
     * @param string $search
1364 
     * @param int $page
1365 
     * @param int $records_per_page
1366 
     * @param string $order_field
1367 
     * @param string $order_direction
1368 
     * @return Paginator
1369 
     */
5973 anderson 1370 
    public function fetchAllDataTable($search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
1 www 1371 
    {
1372 
        $prototype = new User();
1373 
        $select = $this->sql->select(self::_TABLE);
1374 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
5973 anderson 1375 
 
1376 
 
1377 
        if ($search) {
1 www 1378 
            $select->where->nest()
5973 anderson 1379 
                ->like('first_name', '%' . $search . '%')
1380 
                ->or->like('last_name', '%' . $search . '%')
1381 
                ->or->like('email', '%' . $search . '%')
1382 
                ->unnest();
1 www 1383 
        }
1384 
 
5973 anderson 1385 
 
1 www 1386 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1387 
 
1 www 1388 
        $hydrator   = new ObjectPropertyHydrator();
1389 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1390 
 
1 www 1391 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1392 
        $paginator = new Paginator($adapter);
1393 
        $paginator->setItemCountPerPage($records_per_page);
1394 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1395 
 
1396 
 
1 www 1397 
        return $paginator;
1398 
    }
5973 anderson 1399 
 
1 www 1400 
    /**
4398 efrain 1401 
     *
4751 efrain 1402 
     * @param int $network_id
1403 
     * @param string $search
1404 
     * @param int $page
1405 
     * @param int $records_per_page
1406 
     * @param string $order_field
1407 
     * @param string $order_direction
1408 
     * @return Paginator
1409 
     */
5973 anderson 1410 
    public function fetchAllDataTableByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4751 efrain 1411 
    {
1412 
        $prototype = new User();
1413 
        $select = $this->sql->select(self::_TABLE);
1414 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
4776 efrain 1415 
        $select->where->equalTo('network_id', $network_id);
1416 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_APPROVED);
5973 anderson 1417 
 
1418 
 
1419 
        if ($search) {
4751 efrain 1420 
            $select->where->nest()
5973 anderson 1421 
                ->like('first_name', '%' . $search . '%')
1422 
                ->or->like('last_name', '%' . $search . '%')
1423 
                ->or->like('email', '%' . $search . '%')
1424 
                ->unnest();
4751 efrain 1425 
        }
5973 anderson 1426 
 
1427 
 
4751 efrain 1428 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1429 
 
4751 efrain 1430 
        $hydrator   = new ObjectPropertyHydrator();
1431 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1432 
 
4751 efrain 1433 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1434 
        $paginator = new Paginator($adapter);
1435 
        $paginator->setItemCountPerPage($records_per_page);
1436 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1437 
 
1438 
 
4751 efrain 1439 
        return $paginator;
1440 
    }
5973 anderson 1441 
 
1442 
 
1443 
 
1444 
 
4776 efrain 1445 
    /**
1446 
     *
1447 
     * @param int $network_id
1448 
     * @param string $search
1449 
     * @param int $page
1450 
     * @param int $records_per_page
1451 
     * @param string $order_field
1452 
     * @param string $order_direction
1453 
     * @return Paginator
1454 
     */
5973 anderson 1455 
    public function fetchAllDataTableRequestAccessPendingByNetworkId($network_id, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
4776 efrain 1456 
    {
1457 
        $prototype = new User();
1458 
        $select = $this->sql->select(self::_TABLE);
1459 
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
1460 
        $select->where->equalTo('network_id', $network_id);
1461 
        $select->where->equalTo('request_access', User::REQUEST_ACCESS_PENDING);
5973 anderson 1462 
 
1463 
        if ($search) {
4776 efrain 1464 
            $select->where->nest()
5973 anderson 1465 
                ->like('first_name', '%' . $search . '%')
1466 
                ->or->like('last_name', '%' . $search . '%')
1467 
                ->or->like('email', '%' . $search . '%')
1468 
                ->unnest();
4776 efrain 1469 
        }
5973 anderson 1470 
 
1471 
 
4776 efrain 1472 
        $select->order($order_field . ' ' . $order_direction);
5973 anderson 1473 
 
4776 efrain 1474 
        $hydrator   = new ObjectPropertyHydrator();
1475 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
5973 anderson 1476 
 
4776 efrain 1477 
        $adapter = new DbSelect($select, $this->sql, $resultset);
1478 
        $paginator = new Paginator($adapter);
1479 
        $paginator->setItemCountPerPage($records_per_page);
1480 
        $paginator->setCurrentPageNumber($page);
5973 anderson 1481 
 
1482 
 
4776 efrain 1483 
        return $paginator;
1484 
    }
4751 efrain 1485 
 
5973 anderson 1486 
 
4751 efrain 1487 
    /**
1488 
     *
4398 efrain 1489 
     * @param int $id
1490 
     * @return boolean
1491 
     */
1492 
    public function markIsAdult($id)
1493 
    {
1494 
        $update = $this->sql->update(self::_TABLE);
1495 
        $update->set([
1496 
            'id_adult' => User::IS_ADULT_YES,
1497 
        ]);
1498 
        $update->where->equalTo('id', $id);
5973 anderson 1499 
 
4398 efrain 1500 
        return $this->executeUpdate($update);
1501 
    }
5973 anderson 1502 
 
4398 efrain 1503 
    /**
1504 
     *
1505 
     * @param int $id
1506 
     * @return boolean
1507 
     */
1508 
    public function markIsNotAdult($id)
1509 
    {
1510 
        $update = $this->sql->update(self::_TABLE);
1511 
        $update->set([
1512 
            'id_adult' => User::IS_ADULT_NO,
1513 
        ]);
1514 
        $update->where->equalTo('id', $id);
5973 anderson 1515 
 
4398 efrain 1516 
        return $this->executeUpdate($update);
1517 
    }
5973 anderson 1518 
 
4398 efrain 1519 
    /**
1 www 1520 
     *
1521 
     * @param int $id
1522 
     * @return boolean
1523 
     */
1524 
    public function updateChatOnlineStatus($id)
1525 
    {
1526 
        $update = $this->sql->update(self::_TABLE);
1527 
        $update->set([
5973 anderson 1528 
            'online' => 1,
1 www 1529 
        ]);
1530 
        $update->where->equalTo('id', $id);
5973 anderson 1531 
 
1 www 1532 
        return $this->executeUpdate($update);
1533 
    }
3086 efrain 1534 
 
5973 anderson 1535 
 
1536 
 
1 www 1537 
    /**
1538 
     *
1539 
     * @param int $id
1540 
     * @return boolean
1541 
     */
1542 
    public function updateLastActivity($id)
1543 
    {
1544 
        $update = $this->sql->update(self::_TABLE);
1545 
        $update->set([
1546 
            'last_activity_on' => new Expression('NOW()'),
3086 efrain 1547 
            'online' => 1,
1 www 1548 
        ]);
1549 
        $update->where->equalTo('id', $id);
5973 anderson 1550 
 
1 www 1551 
        return $this->executeUpdate($update);
1552 
    }
5973 anderson 1553 
 
1554 
 
1 www 1555 
    /**
1556 
     *
1557 
     * @param int $id
1558 
     * @return boolean
1559 
     */
1560 
    public function updateLastHeartBeat($id)
1561 
    {
1562 
        $update = $this->sql->update(self::_TABLE);
1563 
        $update->set([
1564 
            'last_heart_beat_at' => new Expression('NOW()'),
242 efrain 1565 
            'online' => 1,
1566 
 
1 www 1567 
        ]);
1568 
        $update->where->equalTo('id', $id);
5973 anderson 1569 
 
1 www 1570 
        return $this->executeUpdate($update);
1571 
    }
5973 anderson 1572 
 
242 efrain 1573 
    /**
1574 
     *
1575 
     * @param int $id
1576 
     * @return boolean
1577 
     */
1578 
    public function emailVerifyAndActive($id)
1579 
    {
1580 
        $update = $this->sql->update(self::_TABLE);
1581 
        $update->set([
1582 
            'email_verified' => User::EMAIL_VERIFIED_YES,
5973 anderson 1583 
            'status' => User::STATUS_ACTIVE,
242 efrain 1584 
        ]);
1585 
        $update->where->equalTo('id', $id);
5973 anderson 1586 
 
242 efrain 1587 
        return $this->executeUpdate($update);
1588 
    }
5973 anderson 1589 
 
1590 
 
630 efrain 1591 
    /**
1592 
     *
1593 
     * @param int $company_id
1594 
     * @return User[]
1595 
     */
1596 
    public function fetchAllVerifyAndActiveByCompanyId($company_id)
1597 
    {
1598 
        $select = $this->sql->select();
1599 
        $select->columns(['status', 'company_id']);
1600 
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
5973 anderson 1601 
        $select->join(['tb2' => self::_TABLE], 'tb1.user_id = tb2.id');
630 efrain 1602 
 
5973 anderson 1603 
 
1604 
 
630 efrain 1605 
        $select->where->equalTo('tb1.company_id', $company_id);
1606 
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
1607 
        $select->where->in('tb1.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
1608 
        $select->where->equalTo('tb2.email_verified', User::EMAIL_VERIFIED_YES);
1609 
        $select->where->equalTo('tb2.status', User::STATUS_ACTIVE);
5973 anderson 1610 
 
630 efrain 1611 
        $select->order('first_name', 'last_name', 'email');
1612 
 
1613 
        $prototype = User();
5973 anderson 1614 
 
630 efrain 1615 
        return $this->executeFetchAllObject($select, $prototype);
1616 
    }
1 www 1617 
}