Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 242 | Rev 646 | 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;
21
 
22
 
23
class UserMapper extends MapperCommon
24
{
25
    const _TABLE = 'tbl_users';
26
 
27
    /**
28
     *
29
     * @var UserMapper
30
     */
31
    private static $_instance;
32
 
33
    /**
34
     *
35
     * @param AdapterInterface $adapter
36
     */
37
    private function __construct($adapter)
38
    {
39
        parent::__construct($adapter);
40
    }
41
 
42
    /**
43
     *
44
     * @param AdapterInterface $adapter
45
     * @return UserMapper
46
     */
47
    public static function getInstance($adapter)
48
    {
49
        if(self::$_instance == null) {
50
            self::$_instance = new UserMapper($adapter);
51
        }
52
        return self::$_instance;
53
    }
54
 
55
    /**
56
     *
57
     * @param string $uuid
58
     * @return User
59
     */
60
    public function fetchOneByUuid($uuid)
61
    {
62
        $prototype = new User();
63
        $select = $this->sql->select(self::_TABLE);
64
        $select->where->equalTo('uuid', $uuid);
65
 
66
 
67
        return $this->executeFetchOneObject($select, $prototype);
68
    }
69
 
70
    /**
71
     *
72
     * @param int $id
73
     * @return User
74
     */
75
    public function fetchOne($id)
76
    {
77
        $prototype = new User();
78
        $select = $this->sql->select(self::_TABLE);
79
        $select->where->equalTo('id', $id);
80
 
81
        return $this->executeFetchOneObject($select, $prototype);
82
    }
83
 
84
    /**
85
     *
86
     * @param string $email
87
     * @return void|User
88
     */
89
    public function fetchOneByEmail($email)
90
    {
91
        $prototype = new User();
92
        $select = $this->sql->select(self::_TABLE);
93
        $select->where->equalTo('email', $email);
94
 
95
        //echo $select->getSqlString($this->adapter->platform); exit;
96
 
97
        return $this->executeFetchOneObject($select, $prototype);
98
    }
99
 
100
    /**
101
     *
102
     * @param string $password_reset_key
103
     * @return void|User
104
     */
105
    public function fetchOneByPasswordResetKey($password_reset_key)
106
    {
107
        $prototype = new User();
108
        $select = $this->sql->select(self::_TABLE);
109
        $select->where->equalTo('password_reset_key', $password_reset_key);
110
 
111
        return $this->executeFetchOneObject($select, $prototype);
112
    }
113
 
114
    /**
115
     *
116
     * @param string $activation_key
117
     * @return void|User
118
     */
119
    public function fetchOneByActivationKey($activation_key)
120
    {
121
        $prototype = new User();
122
        $select = $this->sql->select(self::_TABLE);
123
        $select->where->equalTo('activation_key', $activation_key);
124
 
125
        return $this->executeFetchOneObject($select, $prototype);
126
    }
127
 
128
 
129
 
130
    /**
131
     *
132
     * @param string $keyword
133
     * @param int $current_user
134
     * @return User[]
135
     */
136
    public function fetchAllByKeyword($keyword, $current_user = 0)
137
    {
138
 
139
        $prototype = new User();
140
 
141
        $select = $this->sql->select(self::_TABLE);
142
 
143
        $select->where->equalTo('status', User::STATUS_ACTIVE);
144
        $select->where->notEqualTo('id', $current_user);
145
        $select->where->and->nest()
146
            ->like('first_name', '%' . $keyword . '%')
147
            ->or->like('last_name', '%' . $keyword . '%')
148
            ->or->like(new Expression("CONCAT(first_name,' ',last_name)"), '%'. $keyword . '%')
149
            ->unnest();
150
 
151
 
152
        return $this->executeFetchAllObject($select, $prototype);
153
    }
154
 
155
    /**
156
     *
157
     * @param int[] $ids
158
     * @param int $current_user
159
     * @param string $status
160
     * @return User[]
161
     */
162
    public function fetchAllByIds($ids, $current_user = 0, $status = User::STATUS_ACTIVE)
163
    {
164
 
165
        $prototype = new User();
166
        $select = $this->sql->select(self::_TABLE);
167
 
168
 
169
        $select->where->equalTo('status', User::STATUS_ACTIVE);
630 efrain 170
        $select->where->and->in('id',$ids);
1 www 171
 
172
        if($current_user) {
173
            $select->where->and->notEqualTo('id ', $current_user);
174
        }
630 efrain 175
        $select->order(['first_name ASC', 'last_name ASC', 'email ASC']);
1 www 176
 
177
        return $this->executeFetchAllObject($select, $prototype);
178
    }
179
 
180
 
181
    /**
182
     *
183
     * @return User[]
184
     */
185
    public function fetchAllByActives()
186
    {
187
 
188
        $prototype = new User();
189
        $select = $this->sql->select(self::_TABLE);
190
 
191
 
192
        $select->where->equalTo('status', User::STATUS_ACTIVE);
193
        $select->where->equalTo('email_verified',User::EMAIL_VERIFIED_YES);
194
 
195
 
196
        return $this->executeFetchAllObject($select, $prototype);
197
    }
198
 
199
    /**
200
     *
201
     * @param int $user_id
202
     * @param string $password_reset_key
203
     * @return boolean
204
     */
205
    public function updatePasswordResetKey($user_id, $password_reset_key)
206
    {
207
        $values = [
208
            'password_reset_key' => $password_reset_key,
209
            'password_generated_on' => date('Y-m-d H:i:s'),
210
            'updated_on' => new Expression('NOW()')
211
        ];
212
 
213
        $update = $this->sql->update(self::_TABLE);
214
        $update->set($values);
215
        $update->where->equalTo('id', $user_id);
216
 
217
        return $this->executeUpdate($update);
218
    }
219
 
220
 
221
 
222
    /**
223
     *
224
     * @param User $user
225
     * @param string $password_hash
226
     * @return boolean
227
     */
228
    public function updatePassword($user, $password_hash)
229
    {
230
        $values = [
231
            'password'              => $password_hash,
232
            'password_reset_key'    => '',
233
            'password_updated_on'   => date('Y-m-d H:i:s'),
234
            'login_attempt'         => 0,
235
            'blocked'               => User::BLOCKED_NO,
236
            'updated_on'            => new Expression('NOW()')
237
        ];
238
 
239
        $update = $this->sql->update(self::_TABLE);
240
        $update->set($values);
241
        $update->where->equalTo('id', $user->id);
242
 
243
        return $this->executeUpdate($update);
244
    }
245
 
246
 
247
    /**
248
     *
249
     * @param User $user
250
     * @return boolean
251
     */
252
    public function unblock($user)
253
    {
254
        $values = [
255
            'login_attempt'         => 0,
256
            'blocked'               => User::BLOCKED_NO,
257
            'updated_on'            => new Expression('NOW()')
258
        ];
259
 
260
        $update = $this->sql->update(self::_TABLE);
261
        $update->set($values);
262
        $update->where->equalTo('id', $user->id);
263
 
264
        return $this->executeUpdate($update);
265
    }
266
 
267
 
268
 
269
 
270
    /**
271
     *
272
     * @param User $user
273
     * @param string $one_time_password
274
     * @return boolean
275
     */
276
    public function updateOneTimePassword($user, $one_time_password)
277
    {
278
        $values = [
279
            'one_time_password' => $one_time_password,
280
            'updated_on'        => new Expression('NOW()')
281
        ];
282
 
283
        $update = $this->sql->update(self::_TABLE);
284
        $update->set($values);
285
        $update->where->equalTo('id', $user->id);
286
 
287
        return $this->executeUpdate($update);
288
    }
289
 
290
 
291
    /**
292
     *
293
     * @param User $user
294
     * @return boolean
295
     */
296
    public function update($user)
297
    {
298
        $hydrator = new ObjectPropertyHydrator();
299
        $values = $hydrator->extract($user);
300
        $value = $this->removeEmpty($values);
301
 
302
        $values['updated_on'] = new Expression('NOW()') ;
303
 
304
        $update = $this->sql->update(self::_TABLE);
305
        $update->set($values);
306
        $update->where->equalTo('id',$user->id);
307
 
308
        return $this->executeUpdate($update);
309
    }
310
 
311
    /**
312
     *
313
     * @param User $user
314
     * @return boolean
315
     */
316
    public function updatePrivacy($user)
317
    {
318
        $values = [
319
            'show_in_search' => $user->show_in_search,
320
            'updated_on' => new Expression('NOW()')
321
        ];
322
 
323
        $update = $this->sql->update(self::_TABLE);
324
        $update->set($values);
325
        $update->where->equalTo('id',$user->id);
326
 
327
        return $this->executeUpdate($update);
328
    }
329
 
330
    /**
331
     *
332
     * @param User $user
333
     * @return boolean
334
     */
335
    public function updateBasic($user)
336
    {
337
        $values = [
338
            'first_name' => $user->first_name,
339
            'last_name' => $user->last_name,
340
            'phone' => $user->phone,
341
            'gender' => $user->gender,
342
            'updated_on' => new Expression('NOW()')
343
        ];
344
 
345
        $update = $this->sql->update(self::_TABLE);
346
        $update->set($values);
347
        $update->where->equalTo('id',$user->id);
348
 
349
        return $this->executeUpdate($update);
350
    }
351
 
352
 
353
    /**
354
     *
355
     * @param User $user
356
     * @return boolean
357
     */
358
    public function updateImage($user)
359
    {
360
        $values = [
361
            'image' => $user->image,
362
            'updated_on' => new Expression('NOW()')
363
        ];
364
 
365
        $update = $this->sql->update(self::_TABLE);
366
        $update->set($values);
367
        $update->where->equalTo('id',$user->id);
368
 
369
        return $this->executeUpdate($update);
370
    }
371
 
372
    /**
373
     *
374
     * @param User $user
375
     * @return boolean
376
     */
377
    public function updateLocation($user)
378
    {
379
        $values = [
380
            'location_id' => $user->location_id,
381
            'updated_on' => new Expression('NOW()')
382
        ];
383
 
384
        $update = $this->sql->update(self::_TABLE);
385
        $update->set($values);
386
        $update->where->equalTo('id',$user->id);
387
 
388
        return $this->executeUpdate($update);
389
    }
390
 
391
    /**
392
     *
393
     * @param int $user_id
394
     * @return boolean
395
     */
396
    public function activateAccount($user_id)
397
    {
398
        $values = [
399
            'email_verified'    => User::EMAIL_VERIFIED_YES,
400
            'status'            => User::STATUS_ACTIVE,
401
            'activation_key'    => '',
402
            'updated_on' => new Expression('NOW()')
403
        ];
404
 
405
        $update = $this->sql->update(self::_TABLE);
406
        $update->set($values);
407
        $update->where->equalTo('id', $user_id);
408
 
409
        return $this->executeUpdate($update);
410
    }
411
 
412
    /**
413
     *
414
     * @param User $user
415
     * @return boolean
416
     */
417
    public function insert($user)
418
    {
419
 
420
        $hydrator = new ObjectPropertyHydrator();
421
        $values = $hydrator->extract($user);
422
        $values = $this->removeEmpty($values);
423
 
424
        $insert = $this->sql->insert(self::_TABLE);
425
        $insert->values($values);
426
 
427
        $response = $this->executeInsert($insert);
428
        if($response) {
429
            $user->id = $this->lastInsertId;
430
        }
431
 
432
        return $response;
433
    }
434
 
435
 
436
    /**
437
     *
438
     * @return boolean
439
     */
440
    public function truncate()
441
    {
442
        $sql = sprintf('TRUNCATE TABLE `%s` ', self::_TABLE);
443
        return $this->executeSentenceWithParameters($sql);
444
    }
445
 
446
    /**
447
     *
448
     * @param int $company_id
449
     * @param string $status
450
     * @param string $search
451
     * @param int $page
452
     * @param int $records_per_page
453
     * @param string $order_field
454
     * @param string $order_direction
455
     * @return Paginator
456
     */
457
    public function fetchAllDataTableByCompanyId($company_id, $status = '', $search, $page = 1, $records_per_page = 10, $order_field= 'name', $order_direction = 'ASC')
458
    {
459
        $select = $this->sql->select();
460
        $select->columns(['status', 'backend', 'creator']);
461
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
462
        $select->join(['tb2' => self::_TABLE] , 'tb1.user_id = tb2.id', [
463
            'id', 'uuid', 'first_name', 'last_name', 'email', 'last_activity_on', 'image',
464
            'blocked', 'login_attempt', 'email_verified'
465
 
466
        ]);
467
 
468
        $select->where->equalTo('tb1.company_id', $company_id);
469
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
470
 
471
        if($status) {
472
            $select->where->equalTo('tb1.status', $status);
473
 
474
        }
475
 
476
        if($search) {
477
            $select->where->nest()
478
            ->like('first_name', '%' . $search . '%')
479
            ->or->like('last_name', '%' . $search . '%')
480
            ->or->like('email', '%' . $search . '%')
481
            ->unnest();
482
 
483
        }
484
 
485
 
486
        $select->order($order_field . ' ' . $order_direction);
487
 
488
        $hydrator   = new ArraySerializableHydrator();
489
        $resultset  = new HydratingResultSet($hydrator);
490
 
491
        $adapter = new DbSelect($select, $this->sql, $resultset);
492
        $paginator = new Paginator($adapter);
493
        $paginator->setItemCountPerPage($records_per_page);
494
        $paginator->setCurrentPageNumber($page);
495
 
496
 
497
        return $paginator;
498
    }
499
 
500
 
501
    /**
502
     *
503
     * @param int $company_id
504
     * @param string $search
505
     * @param int $page
506
     * @param int $records_per_page
507
     * @param string $order_field
508
     * @param string $order_direction
509
     * @return Paginator
510
     */
511
    public function fetchAllDataTableStudensByCompanyId($company_id,  $search, $page = 1, $records_per_page = 10, $order_field= 'name', $order_direction = 'ASC')
512
    {
513
        $date = date('Y-m-d');
514
 
515
        $selectCapsuleUser = $this->getSql()->select();
516
        $selectCapsuleUser->columns(['user_id' => new Expression('DISTINCT(user_id)')  ]);
517
        $selectCapsuleUser->from(CompanyMicrolearningCapsuleUserMapper::_TABLE);
518
        $selectCapsuleUser->where->equalTo('company_id', $company_id);
519
        $selectCapsuleUser->where->nest->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_UNLIMITED)->or->nest()
520
        ->equalTo('access', CompanyMicrolearningCapsuleUser::ACCESS_PAY_PERIOD)
521
        ->and->lessThanOrEqualTo(new Expression('DATE(paid_from)'), $date)
522
        ->and->greaterThanOrEqualTo(new Expression('DATE(paid_to)'), $date )->unnest()->unnest();
523
 
524
        //echo $select->getSqlString($this->adapter->platform); exit;
525
 
526
        $select = $this->sql->select();
527
        $select->columns(['id' , 'uuid', 'first_name', 'last_name', 'email','blocked']);
528
        $select->from(UserMapper::_TABLE);
529
        $select->where->in('id', $selectCapsuleUser);
530
 
531
 
532
        if($search) {
533
            $select->where->nest()
534
            ->like('first_name', '%' . $search . '%')
535
            ->or->like('last_name', '%' . $search . '%')
536
            ->or->like('email', '%' . $search . '%')
537
            ->unnest();
538
 
539
        }
540
 
541
 
542
        $select->order($order_field . ' ' . $order_direction);
543
 
544
        $hydrator   = new ArraySerializableHydrator();
545
        $resultset  = new HydratingResultSet($hydrator);
546
 
547
        $adapter = new DbSelect($select, $this->sql, $resultset);
548
        $paginator = new Paginator($adapter);
549
        $paginator->setItemCountPerPage($records_per_page);
550
        $paginator->setCurrentPageNumber($page);
551
 
552
 
553
        return $paginator;
554
    }
555
 
556
    /**
557
     *
558
     * @param string $search
559
     * @return User[]
560
     */
561
    public function fetchAllSuggest($search)
562
    {
563
 
564
        $select = $this->sql->select();
565
        $select->from(self::_TABLE);
566
        $select->where->equalTo('status', User::STATUS_ACTIVE);
567
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
568
 
569
        if($search) {
570
            $select->where->nest()
571
            ->like('first_name', '%' . $search . '%')
572
            ->or->like('last_name', '%' . $search . '%')
573
            ->or->like('email', '%' . $search . '%')
574
            ->unnest();
575
 
576
        }
577
 
578
        $select->order(['first_name', 'last_name']);
579
 
580
        // echo $select->getSqlString($this->adapter->platform); exit;
581
 
582
        $prototype = new User();
583
 
584
        return $this->executeFetchAllObject($select, $prototype);
585
    }
586
 
587
 
588
    /**
589
     *
590
     * @param int $company_id
591
     * @param string $search
592
     * @return User[]
593
     */
594
    public function fetchAllSuggestForInvitationByCompanyId($company_id, $search)
595
    {
596
        $selectCompanyUsers = $this->sql->select(CompanyUserMapper::_TABLE);
597
        $selectCompanyUsers->columns(['user_id']);
598
        $selectCompanyUsers->where->equalTo('company_id', $company_id);
599
        $selectCompanyUsers->where->in('status', [
600
            CompanyUser::STATUS_ACCEPTED,
601
            CompanyUser::STATUS_PENDING,
602
            CompanyUser::STATUS_SENT,
603
 
604
        ]);
605
 
606
        //echo $selectCompanyUsers->getSqlString($this->adapter->platform); exit;
607
 
608
        $select = $this->sql->select();
609
        $select->from(self::_TABLE);
610
        $select->where->notIn('id', $selectCompanyUsers);
611
        $select->where->equalTo('status', User::STATUS_ACTIVE);
612
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
613
 
614
        if($search) {
615
            $select->where->nest()
616
            ->like('first_name', '%' . $search . '%')
617
            ->or->like('last_name', '%' . $search . '%')
618
            ->or->like('email', '%' . $search . '%')
619
            ->unnest();
620
 
621
        }
622
 
623
        $select->order(['first_name', 'last_name']);
624
 
625
       // echo $select->getSqlString($this->adapter->platform); exit;
626
 
627
        $prototype = new User();
628
 
629
        return $this->executeFetchAllObject($select, $prototype);
630
    }
631
 
632
    /**
633
     *
634
     * @param int $group_id
635
     * @param string $search
636
     * @return User[]
637
     */
638
    public function fetchAllSuggestForInvitationByGroupId($group_id, $search)
639
    {
640
        $selectGroupMembers = $this->sql->select(GroupMemberMapper::_TABLE);
641
        $selectGroupMembers->columns(['user_id']);
642
        $selectGroupMembers->where->equalTo('group_id', $group_id);
643
        $selectGroupMembers->where->in('status', [
644
         CompanyUser::STATUS_ACCEPTED,
645
        ]);
646
 
647
        //echo $selectGroupMembers->getSqlString($this->adapter->platform); exit;
648
 
649
        $select = $this->sql->select();
650
        $select->from(self::_TABLE);
651
        $select->where->notIn('id', $selectGroupMembers);
652
        $select->where->equalTo('status', User::STATUS_ACTIVE);
653
        $select->where->equalTo('email_verified', User::EMAIL_VERIFIED_YES);
654
 
655
        if($search) {
656
            $select->where->nest()
657
            ->like('first_name', '%' . $search . '%')
658
            ->or->like('last_name', '%' . $search . '%')
659
            ->or->like('email', '%' . $search . '%')
660
            ->unnest();
661
 
662
        }
663
 
664
        $select->order(['first_name', 'last_name']);
665
 
666
        // echo $select->getSqlString($this->adapter->platform); exit;
667
 
668
        $prototype = new User();
669
 
670
        return $this->executeFetchAllObject($select, $prototype);
671
    }
672
 
673
    /**
674
     *
675
     * @param string $search
676
     * @param int $page
677
     * @param int $records_per_page
678
     * @param string $order_field
679
     * @param string $order_direction
680
     * @return Paginator
681
     */
682
    public function fetchAllDataTable($search, $page = 1, $records_per_page = 10, $order_field= 'name', $order_direction = 'ASC')
683
    {
684
        $prototype = new User();
685
        $select = $this->sql->select(self::_TABLE);
686
        $select->where->in('usertype_id', [UserType::ADMIN, UserType::USER]);
687
 
688
 
689
        if($search) {
690
            $select->where->nest()
691
            ->like('first_name', '%' . $search . '%')
692
            ->or->like('last_name', '%' . $search . '%')
693
            ->or->like('email', '%' . $search . '%')
694
            ->unnest();
695
 
696
        }
697
 
698
 
699
        $select->order($order_field . ' ' . $order_direction);
700
 
701
        $hydrator   = new ObjectPropertyHydrator();
702
        $resultset  = new HydratingResultSet($hydrator, $prototype);
703
 
704
        $adapter = new DbSelect($select, $this->sql, $resultset);
705
        $paginator = new Paginator($adapter);
706
        $paginator->setItemCountPerPage($records_per_page);
707
        $paginator->setCurrentPageNumber($page);
708
 
709
 
710
        return $paginator;
711
    }
712
 
713
    /**
714
     *
715
     * @param int $id
716
     * @return boolean
717
     */
718
    public function updateChatOnlineStatus($id)
719
    {
720
        $update = $this->sql->update(self::_TABLE);
721
        $update->set([
722
            'online' => 1,
723
        ]);
724
        $update->where->equalTo('id', $id);
725
 
726
        return $this->executeUpdate($update);
727
    }
728
 
729
    /**
730
     *
731
     * @param int $id
732
     * @return boolean
733
     */
734
    public function updateChatOfflineStatus($id)
735
    {
736
        $update = $this->sql->update(self::_TABLE);
737
        $update->set([
738
            'online' => 0,
739
        ]);
740
        $update->where->equalTo('id', $id);
741
 
742
        return $this->executeUpdate($update);
743
    }
744
 
745
    /**
746
     *
747
     * @param int $id
748
     * @return boolean
749
     */
750
    public function updateLastActivity($id)
751
    {
752
        $update = $this->sql->update(self::_TABLE);
753
        $update->set([
754
            'last_activity_on' => new Expression('NOW()'),
755
        ]);
756
        $update->where->equalTo('id', $id);
757
 
758
        return $this->executeUpdate($update);
759
    }
760
 
761
 
762
    /**
763
     *
764
     * @param int $id
765
     * @return boolean
766
     */
767
    public function updateLastHeartBeat($id)
768
    {
769
        $update = $this->sql->update(self::_TABLE);
770
        $update->set([
771
            'last_heart_beat_at' => new Expression('NOW()'),
242 efrain 772
            'online' => 1,
773
 
1 www 774
        ]);
775
        $update->where->equalTo('id', $id);
776
 
777
        return $this->executeUpdate($update);
778
    }
242 efrain 779
 
780
    /**
781
     *
782
     * @param int $id
783
     * @return boolean
784
     */
785
    public function emailVerifyAndActive($id)
786
    {
787
        $update = $this->sql->update(self::_TABLE);
788
        $update->set([
789
            'email_verified' => User::EMAIL_VERIFIED_YES,
790
            'status' => User::STATUS_ACTIVE,
791
        ]);
792
        $update->where->equalTo('id', $id);
1 www 793
 
242 efrain 794
        return $this->executeUpdate($update);
795
    }
796
 
630 efrain 797
 
798
    /**
799
     *
800
     * @param int $company_id
801
     * @return User[]
802
     */
803
    public function fetchAllVerifyAndActiveByCompanyId($company_id)
804
    {
805
        $select = $this->sql->select();
806
        $select->columns(['status', 'company_id']);
807
        $select->from(['tb1' => CompanyUserMapper::_TABLE]);
808
        $select->join(['tb2' => self::_TABLE] , 'tb1.user_id = tb2.id');
809
 
810
 
811
 
812
        $select->where->equalTo('tb1.company_id', $company_id);
813
        $select->where->equalTo('tb1.owner', CompanyUser::OWNER_NO);
814
        $select->where->in('tb1.status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
815
        $select->where->equalTo('tb2.email_verified', User::EMAIL_VERIFIED_YES);
816
        $select->where->equalTo('tb2.status', User::STATUS_ACTIVE);
817
 
818
        $select->order('first_name', 'last_name', 'email');
819
 
820
        $prototype = User();
821
 
822
        return $this->executeFetchAllObject($select, $prototype);
823
    }
1 www 824
}