Proyectos de Subversion LeadersLinked - Services

Rev

Rev 167 | Rev 195 | Ir a la última revisión | | Comparar con el anterior | Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1
<?php
2
 
3
declare(strict_types=1);
4
 
5
namespace LeadersLinked\Controller;
6
 
7
use Laminas\Db\Adapter\AdapterInterface;
8
 
9
use Laminas\Mvc\Controller\AbstractActionController;
10
use Laminas\Log\LoggerInterface;
11
use Laminas\View\Model\JsonModel;
12
use LeadersLinked\Mapper\CalendarEventMapper;
13
use LeadersLinked\Mapper\CompanyFollowerMapper;
14
use LeadersLinked\Mapper\CompanyServiceMapper;
15
use LeadersLinked\Mapper\JobDescriptionMapper;
16
use LeadersLinked\Mapper\PerformanceEvaluationFormMapper;
17
use LeadersLinked\Mapper\PerformanceEvaluationTestMapper;
18
use LeadersLinked\Mapper\QueryMapper;
19
use LeadersLinked\Mapper\RecruitmentSelectionCandidateMapper;
20
use LeadersLinked\Mapper\RecruitmentSelectionInterviewMapper;
21
use LeadersLinked\Mapper\RecruitmentSelectionVacancyMapper;
22
use LeadersLinked\Mapper\UserMapper;
23
use LeadersLinked\Mapper\ZoomMeetingMapper;
24
use LeadersLinked\Library\Functions;
25
use LeadersLinked\Mapper\UserNotificationSettingMapper;
26
 
27
use LeadersLinked\Model\CalendarEvent;
28
use LeadersLinked\Model\PerformanceEvaluationTest;
29
use LeadersLinked\Model\RecruitmentSelectionInterview;
30
use LeadersLinked\Model\User;
31
use LeadersLinked\Mapper\ConnectionMapper;
32
use LeadersLinked\Mapper\ProfileVisitMapper;
33
use LeadersLinked\Mapper\GroupMemberMapper;
34
use LeadersLinked\Model\GroupMember;
35
use LeadersLinked\Mapper\GroupMapper;
36
use LeadersLinked\Model\Group;
37
use Laminas\Db\Sql\Expression;
38
use LeadersLinked\Mapper\CompanyUserMapper;
39
use LeadersLinked\Model\CompanyUser;
40
use LeadersLinked\Model\UserType;
41
use LeadersLinked\Mapper\CompanyMicrolearningCapsuleUserMapper;
42
use LeadersLinked\Model\Notification;
43
use LeadersLinked\Mapper\NotificationMapper;
44
use LeadersLinked\Mapper\EmailTemplateMapper;
45
use LeadersLinked\Model\EmailTemplate;
46
use LeadersLinked\Library\QueueEmail;
47
use LeadersLinked\Mapper\PostMapper;
48
use LeadersLinked\Mapper\CompanyMapper;
49
use LeadersLinked\Model\Company;
50
use LeadersLinked\Model\Connection;
51
use LeadersLinked\Model\Service;
52
use LeadersLinked\Mapper\DailyPulseEmojiMapper;
53
use LeadersLinked\Mapper\UserProfileMapper;
54
use LeadersLinked\Mapper\NetworkMapper;
55
use LeadersLinked\Model\Network;
56
use LeadersLinked\Mapper\LocationMapper;
57
use LeadersLinked\Mapper\CompanySizeMapper;
58
use LeadersLinked\Mapper\DegreeMapper;
59
use LeadersLinked\Mapper\LanguageMapper;
60
use LeadersLinked\Mapper\SkillMapper;
61
use LeadersLinked\Mapper\AptitudeMapper;
62
use LeadersLinked\Mapper\HobbyAndInterestMapper;
63
use LeadersLinked\Mapper\IndustryMapper;
64
use LeadersLinked\Mapper\SurveyTestMapper;
65
use LeadersLinked\Model\SurveyTest;
66
use LeadersLinked\Mapper\SurveyCampaignMapper;
117 efrain 67
use LeadersLinked\Mapper\GroupTypeMapper;
192 efrain 68
use LeadersLinked\Mapper\FeedMapper;
69
use LeadersLinked\Model\Feed;
70
use LeadersLinked\Model\AbuseReport;
71
use LeadersLinked\Form\AbuseReport\CreateForm;
72
use LeadersLinked\Model\Post;
73
use LeadersLinked\Mapper\MessageMapper;
74
use LeadersLinked\Model\Message;
75
use LeadersLinked\Mapper\CommentMapper;
76
use LeadersLinked\Model\Comment;
77
use LeadersLinked\Mapper\ChatMessageMapper;
78
use LeadersLinked\Model\ChatMessage;
79
use LeadersLinked\Mapper\ChatGroupMessageMapper;
80
use LeadersLinked\Mapper\ChatGroupUserMessageMapper;
81
use LeadersLinked\Mapper\AbuseReportMapper;
82
use LeadersLinked\Mapper\UserBlockedMapper;
83
use LeadersLinked\Model\UserBlocked;
1 efrain 84
 
85
class HelperController extends AbstractActionController
86
{
87
    /**
88
     *
89
     * @var \Laminas\Db\Adapter\AdapterInterface
90
     */
91
    private $adapter;
92
 
93
    /**
94
     *
95
     * @var \LeadersLinked\Cache\CacheInterface
96
     */
97
    private $cache;
98
 
99
 
100
    /**
101
     *
102
     * @var \Laminas\Log\LoggerInterface
103
     */
104
    private $logger;
105
 
106
    /**
107
     *
108
     * @var array
109
     */
110
    private $config;
111
 
112
 
113
    /**
114
     *
115
     * @var \Laminas\Mvc\I18n\Translator
116
     */
117
    private $translator;
118
 
119
 
120
    /**
121
     *
122
     * @var array
123
     */
124
    private $navigation;
125
 
126
    /**
127
     *
128
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
129
     * @param \LeadersLinked\Cache\CacheInterface $cache
130
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
131
     * @param array $config
132
     * @param \Laminas\Mvc\I18n\Translator $translator
133
     * @param array $navigation
134
     */
135
    public function __construct($adapter, $cache, $logger, $config, $translator, $navigation)
136
    {
137
        $this->adapter      = $adapter;
138
        $this->cache        = $cache;
139
        $this->logger       = $logger;
140
        $this->config       = $config;
141
        $this->translator   = $translator;
142
        $this->navigation   = $navigation;
143
    }
144
 
145
 
146
    /**
147
     * Recuperamos las personas que pueda conocer
148
     * tiene que enviarse un petición GET a la siguiente url: /helpers/people-you-may-know
149
     * retorna un json en caso de ser  positivo
150
     * [
151
     *  'success' : true,
152
     *  'data' : [
153
     *      [
154
     *        'id'      => 'id del usuario encriptado',
155
     *        'name'    => 'nombre del usuario',
156
     *        'image'   => 'imagen del usuario',
157
     *        'profile' => 'url del profile',
158
     *     ]
159
     * ]
160
     * En caso de ser negativo
161
     * [
162
     *  'success' : false,
163
     *  'data' : mensaje de error
164
     * ]
165
     * @return \Laminas\View\Model\JsonModel
166
     */
167
    public function peopleYouMayKnowAction()
168
    {
169
        $request = $this->getRequest();
170
        if ($request->isGet()) {
171
            $currentUserPlugin = $this->plugin('currentUserPlugin');
172
            $currentUser = $currentUserPlugin->getUser();
173
 
174
            $connectionMapper = ConnectionMapper::getInstance($this->adapter);
175
            $first_degree_connections_ids = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
176
            $first_degree_connections_ids = $first_degree_connections_ids ? $first_degree_connections_ids : [0];
177
 
178
            $second_degree_connections_ids = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
179
            $second_degree_connections_ids = $second_degree_connections_ids ? $second_degree_connections_ids : [0];
180
 
181
            /*Usuarios de la empresas donde trabajo o soy dueño */
182
            $company_user_ids = [];
183
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
184
 
185
            $records = $companyUserMapper->fetchAllByUserId($currentUser->id);
186
            foreach ($records as $record) {
187
 
188
                if ($record->status != CompanyUser::STATUS_ACCEPTED) {
189
                    continue;
190
                }
191
 
192
                $otherUsers = $companyUserMapper->fetchAllByCompanyId($record->company_id);
193
                foreach ($otherUsers as $otherUser) {
194
                    if ($currentUser->id != $otherUser->user_id && $otherUser->creator == CompanyUser::CREATOR_NO && $otherUser->status == CompanyUser::STATUS_ACCEPTED) {
195
 
196
                        if (!in_array($otherUser->user_id, $company_user_ids)) {
197
                            array_push($company_user_ids, $otherUser->user_id);
198
                        }
199
                    }
200
                }
201
            }
202
            $company_user_ids =  $company_user_ids ? $company_user_ids : [0];
203
 
204
            /* Usuario de los grupos donde soy dueño o participo */
205
 
206
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
207
 
208
            $group_member_ids = [];
209
 
210
            $records = $groupMemberMapper->fetchAllByUserId($currentUser->id);
211
            foreach ($records as $record) {
212
                if ($record->status != GroupMember::STATUS_ACCEPTED) {
213
                    continue;
214
                }
215
 
216
                $otherUsers = $groupMemberMapper->fetchAllByGroupId($record->group_id);
217
                foreach ($otherUsers as $otherUser) {
218
                    if ($currentUser->id != $otherUser->user_id && $otherUser->status == GroupMember::STATUS_ACCEPTED) {
219
 
220
                        if (!in_array($otherUser->user_id, $group_member_ids)) {
221
                            array_push($group_member_ids, $otherUser->user_id);
222
                        }
223
                    }
224
                }
225
            }
226
 
227
            $group_member_ids = $group_member_ids ? $group_member_ids : [0];
228
 
229
 
230
 
231
            /* Usuarios con que comparto capsulas */
232
            $capsule_user_ids = [];
233
            $capsuleUserMapper = CompanyMicrolearningCapsuleUserMapper::getInstance($this->adapter);
234
 
235
            $company_ids = [];
236
            $records = $capsuleUserMapper->fetchAllActiveByUserId($currentUser->id);
237
            foreach ($records as $record) {
238
                if (!in_array($record->company_id, $company_ids)) {
239
                    array_push($company_ids, $record->company_id);
240
                }
241
            }
242
 
243
 
244
 
245
            foreach ($company_ids as $company_id) {
246
                $otherUsers = $capsuleUserMapper->fetchAllUserIdsForCapsulesActiveByCompanyId($company_id);
247
                foreach ($otherUsers as $user_id) {
248
                    if ($currentUser->id != $user_id) {
249
 
250
                        if (!in_array($user_id, $capsule_user_ids)) {
251
                            array_push($capsule_user_ids, $user_id);
252
                        }
253
                    }
254
                }
255
            }
256
 
257
            $capsule_user_ids = $capsule_user_ids ? $capsule_user_ids : [0];
258
 
259
 
260
            $other_users = array_unique(array_merge(
261
                $second_degree_connections_ids,
262
                $company_user_ids,
263
                $group_member_ids,
264
                $capsule_user_ids
265
            ));
266
 
267
 
268
 
269
 
270
 
271
 
272
 
273
 
274
            $items = [];
275
            $queryMapper = QueryMapper::getInstance($this->adapter);
276
            $select = $queryMapper->getSql()->select();
277
            $select->columns(['id', 'uuid',  'first_name', 'last_name', 'image']);
278
            $select->from(['u' => UserMapper::_TABLE]);
279
            $select->join(['up' => UserProfileMapper::_TABLE], 'up.user_id = u.id ', ['description']);
280
            $select->where->equalTo('network_id', $currentUser->network_id);
281
            $select->where->in('u.id', $other_users);
282
            $select->where->notIn('u.id', $first_degree_connections_ids);
283
            $select->where->notEqualTo('u.id', $currentUser->id);
284
            $select->where->equalTo('u.status', User::STATUS_ACTIVE);
285
            $select->where->in('u.usertype_id', [UserType::ADMIN, UserType::USER]);
286
            $select->order(['first_name', 'last_name']);
287
 
288
            //echo $select->getSqlString($this->adapter->platform); exit;
289
 
290
            $records = $queryMapper->fetchAll($select);
291
            foreach ($records as $record) {
292
 
293
                $relation = [];
294
                if (in_array($record['id'], $second_degree_connections_ids)) {
295
                    array_push($relation, 'LABEL_RELATION_TYPE_SECOND_GRADE');
296
                }
297
                if (in_array($record['id'], $company_user_ids)) {
298
                    array_push($relation, 'LABEL_RELATION_TYPE_COMPANY_USER');
299
                }
300
                if (in_array($record['id'], $group_member_ids)) {
301
                    array_push($relation, 'LABEL_RELATION_TYPE_GROUP_MEMBER');
302
                }
303
                if (in_array($record['id'], $capsule_user_ids)) {
304
                    array_push($relation, 'LABEL_RELATION_TYPE_CAPSULE_USER');
305
                }
306
 
307
 
308
                $connection = $connectionMapper->fetchOneByUserId1AndUserId2($currentUser->id, $record['id']);
309
 
310
                $item = [
311
                    'id'    => $record['uuid'],
312
                    'name'  => trim($record['first_name'] . ' ' . $record['last_name']),
60 efrain 313
                    'image' => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 314
                    'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid']]),
315
                    'relation' => $relation,
316
                    'link_cancel'   => '',
317
                    'link_request'  => '',
318
                    'user_profile' => $record['description'],
319
                ];
320
 
321
                if ($connection) {
322
                    switch ($connection->status) {
323
                        case Connection::STATUS_SENT:
324
                            $item['link_cancel'] = $this->url()->fromRoute('connection/delete', ['id' => $record['uuid']]);
325
                            break;
326
 
327
                        case Connection::STATUS_ACCEPTED:
328
                            $item['link_cancel'] = $this->url()->fromRoute('connection/cancel', ['id' => $record['uuid']]);
329
                            break;
330
 
331
                        default:
332
                            $item['link_request'] = $this->url()->fromRoute('connection/request', ['id' => $record['uuid']]);
333
                            break;
334
                    }
335
                } else {
336
                    $item['link_request'] = $this->url()->fromRoute('connection/request', ['id' => $record['uuid']]);
337
                }
338
 
339
 
340
                array_push($items, $item);
341
            }
342
 
343
            return new JsonModel([
344
                'success' => true,
345
                'data' => $items
346
            ]);
347
        } else {
348
            return new JsonModel([
349
                'success' => false,
350
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
351
            ]);
352
        }
353
    }
354
 
355
    /**
356
     * Recuperamos las personas que pueda conocer
357
     * tiene que enviarse un petición GET a la siguiente url: /helpers/people-viewed-profile/:user_profile_id
358
     * retorna un json en caso de ser  positivo
359
     * [
360
     *  'success' : true,
361
     *  'data' : [
362
     *      [
363
     *        'id'      => 'id del usuario encriptado',
364
     *        'name'    => 'nombre del usuario',
365
     *        'image'   => 'imagen del usuario',
366
     *        'profile' => 'url del profile',
367
     *     ]
368
     * ]
369
     * En caso de ser negativo
370
     * [
371
     *  'success' : false,
372
     *  'data' : mensaje de error
373
     * ]
374
     * @return \Laminas\View\Model\JsonModel
375
     */
376
    public function peopleViewedProfileAction()
377
    {
378
        $request = $this->getRequest();
379
        if ($request->isGet()) {
380
            $currentUserPlugin = $this->plugin('currentUserPlugin');
381
            $currentUser = $currentUserPlugin->getUser();
382
 
383
            $items = [];
384
            $user_profile_id = $this->params()->fromRoute('user_profile_id');
385
 
386
            $items = [];
387
 
388
            $mapper = QueryMapper::getInstance($this->adapter);
389
            $select = $mapper->getSql()->select(ProfileVisitMapper::_TABLE);
390
            $select->columns(['user_id' => new Expression('DISTINCT(visitor_id)')]);
391
            $select->where->equalTo('user_profile_id', $user_profile_id);
392
            $records = $mapper->fetchAll($select);
393
 
394
            if ($records) {
395
 
396
                $user_ids = [];
397
                foreach ($records as $record) {
398
                    array_push($user_ids, $record['user_id']);
399
                }
400
 
401
                $mapper = QueryMapper::getInstance($this->adapter);
402
                $select = $mapper->getSql()->select(UserMapper::_TABLE);
403
                $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
404
                $select->where->in('id', $user_ids);
405
                $select->where->equalTo('network_id', $currentUser->network_id);
406
                $select->where->equalTo('status', User::STATUS_ACTIVE);
407
                $select->order(['last_name ASC', 'first_name ASC']);
408
 
409
                $records = $mapper->fetchAll($select);
410
                foreach ($records as $record) {
411
                    array_push($items, [
412
                        'id'        => $record['uuid'],
413
                        'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
60 efrain 414
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 415
                        'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid']]),
416
                    ]);
417
                }
418
            }
419
 
420
 
421
            return new JsonModel([
422
                'success' => true,
423
                'data' => $items
424
            ]);
425
        } else {
426
            return new JsonModel([
427
                'success' => false,
428
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
429
            ]);
430
        }
431
    }
432
 
433
 
434
    /**
435
     * Recuperamos los seguidores de la empresa
436
     * tiene que enviarse un petición GET a la siguiente url: /helpers/company-follower/:company_id
437
     * retorna un json en caso de ser  positivo
438
     * [
439
     *  'success' : true,
440
     *  'data' : [
441
     *      [
442
     *        'id'      => 'id del usuario encriptado',
443
     *        'name'    => 'nombre del usuario',
444
     *        'image'   => 'imagen del usuario',
445
     *        'profile' => 'url del profile',
446
     *     ]
447
     * ]
448
     * En caso de ser negativo
449
     * [
450
     *  'success' : false,
451
     *  'data' : mensaje de error
452
     * ]
453
     * @return \Laminas\View\Model\JsonModel
454
     */
455
    public function companyFollowerAction()
456
    {
457
 
458
 
459
        $request = $this->getRequest();
460
        if ($request->isGet()) {
461
            $currentUserPlugin = $this->plugin('currentUserPlugin');
462
            $currentUser = $currentUserPlugin->getUser();
463
 
464
            $company_uuid  = $this->params()->fromRoute('company_id');
465
 
466
            $companyMapper = CompanyMapper::getInstance($this->adapter);
467
            $company = $companyMapper->fetchOneByUuidAndNetworkId($company_uuid, $currentUser->network_id);
468
 
469
            $items = [];
470
            if ($company && $company->status == Company::STATUS_ACTIVE) {
471
 
472
 
473
                //print_r($company);
474
 
475
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
476
                $records = $companyFollowerMapper->fetchAllByCompanyId($company->id);
477
 
478
                $ids = [];
479
                foreach ($records as $record) {
480
                    if (!in_array($record->follower_id, $ids)) {
481
                        array_push($ids, $record->follower_id);
482
                    }
483
                }
484
 
485
                //print_r($records);
486
 
487
 
488
                if ($ids) {
489
 
490
                    $mapper = QueryMapper::getInstance($this->adapter);
491
                    $select = $mapper->getSql()->select(UserMapper::_TABLE);
492
                    $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
493
                    $select->where->equalTo('network_id', $currentUser->network_id);
494
                    $select->where->in('id', $ids);
495
                    $select->where->equalTo('status', User::STATUS_ACTIVE);
496
                    $select->order(['last_name', 'first_name']);
497
 
498
                    //echo $select->getSqlString($this->adapter->platform); exit;
499
 
500
 
501
 
502
                    $records = $mapper->fetchAll($select);
503
                    foreach ($records as $record) {
504
 
505
 
506
                        array_push($items, [
507
                            'id'        => $record['uuid'],
508
                            'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
60 efrain 509
                            'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 510
                            'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid']]),
511
                        ]);
512
                    }
513
                }
514
            }
515
 
516
            return new JsonModel([
517
                'success' => true,
518
                'data' => $items
519
            ]);
520
        } else {
521
            return new JsonModel([
522
                'success' => false,
523
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
524
            ]);
525
        }
526
    }
527
 
528
    public function companySuggestionAction()
529
    {
530
        $request = $this->getRequest();
531
        if ($request->isGet()) {
532
            $currentUserPlugin = $this->plugin('currentUserPlugin');
533
            $currentUser = $currentUserPlugin->getUser();
534
 
535
            $company_uuid = $this->params()->fromRoute('company_id');
536
 
537
            $companyMapper = CompanyMapper::getInstance($this->adapter);
538
            $company = $companyMapper->fetchOneByUuidAndNetworkId($company_uuid, $currentUser->network_id);
539
 
540
            $items = [];
541
            if ($company && $company->status == Company::STATUS_ACTIVE) {
542
 
543
 
544
                $mapper = QueryMapper::getInstance($this->adapter);
545
                $select = $mapper->getSql()->select(CompanyMapper::_TABLE);
546
                $select->columns(['id', 'uuid', 'name', 'image']);
547
                $select->where->equalTo('network_id', $currentUser->network_id);
548
                $select->where->notEqualTo('id', $company->id);
549
                $select->where->equalTo('status', Company::STATUS_ACTIVE);
550
                $select->where->equalTo('industry_id', $company->industry_id);
551
                //  $select->where->equalTo('company_size_id', $company->company_size_id);
552
                $select->order(['name']);
553
 
554
 
555
                //echo $select->getSqlString($this->adapter->platform); exit;
556
 
557
                $records = $mapper->fetchAll($select);
558
                foreach ($records as $record) {
559
                    array_push($items, [
560
                        'id'        => $record['uuid'],
561
                        'name'      => trim($record['name']),
60 efrain 562
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'company', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 563
                        'profile'   => $this->url()->fromRoute('company/view', ['id' => $record['uuid']]),
564
                    ]);
565
                }
566
            }
567
 
568
            return new JsonModel([
569
                'success' => true,
570
                'data' => $items
571
            ]);
572
        } else {
573
            return new JsonModel([
574
                'success' => false,
575
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
576
            ]);
577
        }
578
    }
579
 
580
    /**
581
     * Recuperamos los miembros del grupo
582
     * tiene que enviarse un petición GET a la siguiente url: /helpers/group-members/:group_id
583
     * retorna un json en caso de ser  positivo
584
     * [
585
     *  'success' : true,
586
     *  'data' : [
587
     *      [
588
     *        'id'      => 'id del usuario encriptado',
589
     *        'name'    => 'nombre del usuario',
590
     *        'image'   => 'imagen del usuario',
591
     *        'profile' => 'url del profile',
592
     *     ]
593
     * ]
594
     * En caso de ser negativo
595
     * [
596
     *  'success' : false,
597
     *  'data' : mensaje de error
598
     * ]
599
     * @return \Laminas\View\Model\JsonModel
600
     */
601
    public function groupMembersAction()
602
    {
603
        $currentUserPlugin = $this->plugin('currentUserPlugin');
604
        $currentUser = $currentUserPlugin->getUser();
605
 
606
        $request = $this->getRequest();
607
        if ($request->isGet()) {
608
 
609
            $group_uuid = $this->params()->fromRoute('group_id');
610
 
611
            $groupMapper = GroupMapper::getInstance($this->adapter);
612
            $group = $groupMapper->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);
613
 
614
            $items = [];
615
            if ($group && $group->status == Group::STATUS_ACTIVE) {
616
 
617
                $mapper = QueryMapper::getInstance($this->adapter);
618
                $select = $mapper->getSql()->select();
619
                $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
620
                $select->from(['u' => UserMapper::_TABLE]);
621
                $select->join(['gm' => GroupMemberMapper::_TABLE], 'gm.user_id = u.id ', ['user_id', 'status']);
622
                $select->join(['g' => GroupMapper::_TABLE], 'gm.group_id = g.id', ['group_uuid' => 'uuid']);
623
                $select->where->equalTo('u.network_id',  $currentUser->network_id);
624
                $select->where->equalTo('g.network_id', $currentUser->network_id);
625
                $select->where->equalTo('g.uuid', $group_uuid);
626
 
627
                if ($group->user_id == $currentUser->id) {
628
                    $select->where->in('gm.status', [
629
                        GroupMember::STATUS_ACCEPTED,
630
                        GroupMember::STATUS_ADDED_BY_ADMIN,
631
                        GroupMember::STATUS_AUTO_JOIN,
632
                        GroupMember::STATUS_JOINING_REQUESTED,
633
                    ]);
634
                } else {
635
                    $select->where->in('gm.status', [GroupMember::STATUS_ACCEPTED, GroupMember::STATUS_AUTO_JOIN]);
636
                }
637
 
638
 
639
                $select->where->equalTo('u.status', User::STATUS_ACTIVE);
640
                $select->order(['last_name', 'first_name']);
641
 
642
                //echo $select->getSqlString($this->adapter->platform);
643
 
644
 
645
 
646
 
647
                $records = $mapper->fetchAll($select);
648
                foreach ($records as $record) {
649
 
650
                    $actions = [];
651
                    if ($group->user_id == $currentUser->id) {
652
                        if ($record['id'] != $currentUser->id) {
653
 
654
 
655
 
656
                            switch ($record['status']) {
657
                                case GroupMember::STATUS_JOINING_REQUESTED:
658
                                    $actions['link_approve'] = $this->url()->fromRoute('helpers/group-members/approve', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
659
                                    $actions['link_reject'] = $this->url()->fromRoute('helpers/group-members/reject', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
660
                                    break;
661
 
662
                                case GroupMember::STATUS_ACCEPTED:
663
                                case GroupMember::STATUS_AUTO_JOIN:
664
                                case GroupMember::STATUS_ADDED_BY_ADMIN:
665
                                    $actions['link_cancel'] = $this->url()->fromRoute('helpers/group-members/cancel', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
666
                                    break;
667
                            }
668
                        }
669
                    }
670
 
671
                    array_push($items, [
672
                        'id'        => $record['uuid'],
673
                        'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
60 efrain 674
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 675
                        'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid']]),
676
                        'actions'   => $actions,
677
 
678
                    ]);
679
                }
680
            }
681
 
682
            return new JsonModel([
683
                'success' => true,
684
                'data' => [
685
                    'items' => $items,
686
                    'link_invite' => $group->user_id == $currentUser->id ? $this->url()->fromRoute('helpers/group-members/invite', ['group_id' => $group->uuid])  : '',
687
                ]
688
            ]);
689
        } else {
690
            return new JsonModel([
691
                'success' => false,
692
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
693
            ]);
694
        }
695
    }
696
 
697
    public function groupMemberInviteAction()
698
    {
699
        $currentUserPlugin = $this->plugin('currentUserPlugin');
700
        $currentUser = $currentUserPlugin->getUser();
701
 
702
        $group_uuid = $this->params()->fromRoute('group_id');
703
 
704
        $groupMapper = GroupMapper::getInstance($this->adapter);
705
        $group = $groupMapper->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);
706
 
707
        if (!$group) {
708
            return new JsonModel([
709
                'success' => false,
710
                'data' => 'ERROR_GROUP_NOT_FOUND'
711
            ]);
712
        }
713
 
714
        if ($group->status != Group::STATUS_ACTIVE) {
715
            return new JsonModel([
716
                'success' => false,
717
                'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
718
            ]);
719
        }
720
 
721
        if ($currentUser->id != $group->user_id) {
722
            return new JsonModel([
723
                'success' => false,
724
                'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
725
            ]);
726
        }
727
 
728
 
729
        $request = $this->getRequest();
730
        if ($request->isGet()) {
731
            $search = filter_var($this->params()->fromQuery('search', ''));
732
            if (strlen($search) >= 3) {
733
 
734
                $userMapper = UserMapper::getInstance($this->adapter);
735
                $records  = $userMapper->fetchAllSuggestForInvitationByGroupIdAndNetworkIdAndSearch($group->id, $currentUser->network_id, $search);
736
 
737
                $users = [];
738
                foreach ($records as $record) {
739
                    array_push($users, [
740
                        'value' => $record->uuid,
741
                        'text' => trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')'
742
 
743
                    ]);
744
                }
745
 
746
                return new JsonModel([
747
                    'success' => true,
748
                    'data' => $users
749
                ]);
750
            } else {
751
                return new JsonModel([
752
                    'success' => true,
753
                    'data' => []
754
                ]);
755
            }
756
        } else if ($request->isPost()) {
757
            $uuid = $this->params()->fromPost('id');
758
            if (!$uuid) {
759
                return new JsonModel([
760
                    'success'   => false,
761
                    'data'      => 'ERROR_INVALID_PARAMETER'
762
                ]);
763
            }
764
 
765
            $userMapper = UserMapper::getInstance($this->adapter);
766
            $user = $userMapper->fetchOneByUuidAndNetworkId($uuid, $currentUser->network_id);
767
 
768
            if (!$user) {
769
                return new JsonModel([
770
                    'success'   => false,
771
                    'data'      => 'ERROR_USER_NOT_FOUND'
772
                ]);
773
            }
774
 
775
            if ($user->status != User::STATUS_ACTIVE) {
776
                return new JsonModel([
777
                    'success'   => false,
778
                    'data'      => 'ERROR_USER_IS_INACTIVE'
779
                ]);
780
            }
781
 
782
            if ($group->user_id == $user->id) {
783
                return new JsonModel([
784
                    'success'   => false,
785
                    'data'      => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
786
                ]);
787
            }
788
 
789
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
790
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
791
 
792
 
793
 
794
            if ($groupMember) {
795
                $result = false;
796
 
797
                switch ($groupMember->status) {
798
                    case GroupMember::STATUS_ACCEPTED:
799
                    case GroupMember::STATUS_AUTO_JOIN:
800
 
801
                        return new JsonModel([
802
                            'success'   => false,
803
                            'data'      => 'ERROR_GROUP_YOU_ARE_MEMBER',
804
                        ]);
805
                        break;
806
 
807
 
808
                    case $groupMember->status == GroupMember::STATUS_REJECTED:
809
                    case $groupMember->status == GroupMember::STATUS_CANCELLED:
810
 
811
                        $groupMember->status = GroupMember::STATUS_ADDED_BY_ADMIN;
812
                        $groupMember->joining_request_on = date('H-m-d H:i:s');
813
 
814
                        $result = $groupMemberMapper->update($groupMember);
815
                        break;
816
 
817
                    case GroupMember::STATUS_ADDED_BY_ADMIN:
818
                    case  GroupMember::STATUS_JOINING_REQUESTED:
819
                        return new JsonModel([
820
                            'success'   => false,
821
                            'data'      => 'ERROR_GROUP_THERE_IS_A_PENDING_REQUEST'
822
                        ]);
823
                        break;
824
 
825
                    default:
826
                        return new JsonModel([
827
                            'success'   => false,
828
                            'data'      => 'ERROR_UNKNOWN_OPERATION'
829
                        ]);
830
                        break;
831
                }
832
            } else {
833
 
834
 
835
 
836
                $groupMember = new GroupMember();
837
                $groupMember->user_id = $user->id;
838
                $groupMember->group_id = $group->id;
839
                $groupMember->status = GroupMember::STATUS_ADDED_BY_ADMIN;
840
                $groupMember->joining_request_on = date('H-m-d H:i:s');
841
 
842
                $result = $groupMemberMapper->insert($groupMember);
843
            }
844
 
845
            if ($result) {
846
 
847
                $notification = new Notification();
848
                $notification->type     = Notification::TYPE_RECEIVE_INVITATION_GROUP;
849
                $notification->read     = Notification::NO;
850
                $notification->user_id  = $user->id;
851
                $notification->group_id = $group->id;
852
                $notification->message  = 'LABEL_NOTIFICATION_RECEIVE_INVITATION_GROUP';
853
                $notification->url      = $this->url()->fromRoute('group/view', ['id' => $group->uuid]);
854
 
855
                $notificationMapper = NotificationMapper::getInstance($this->adapter);
856
                $notificationMapper->insert($notification);
857
 
858
                $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
859
                $userNotification = $userNotificationMapper->fetchOne($user->id);
860
 
861
                if ($userNotification && $userNotification->receive_invitation_group) {
862
                    $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
863
                    $emailTemplate = $emailTemplateMapper->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_RECEIVE_INVITATION_GROUP, $currentUser->network_id);
864
 
865
                    if ($emailTemplate) {
866
                        $arrayCont = [
867
                            'firstname'             => $currentUser->first_name,
868
                            'lastname'              => $currentUser->last_name,
869
                            'other_user_firstname'  => $user->first_name,
870
                            'other_user_lastname'   => $user->last_name,
871
                            'company_name'          => '',
872
                            'group_name'            => $group->name,
873
                            'content'               => '',
874
                            'code'                  => '',
875
                            'link'                  => $this->url()->fromRoute('group/view', ['id' => $group->uuid], ['force_canonical' => true])
876
                        ];
877
 
878
                        $email = new QueueEmail($this->adapter);
879
                        $email->processEmailTemplate($emailTemplate, $arrayCont, $user->email, trim($user->first_name . ' ' . $user->last_name));
880
                    }
881
                }
882
 
883
                return new JsonModel([
884
                    'success'   => true,
885
                    'data'      => 'LABEL_GROUP_REQUEST_SUCCESS'
886
                ]);
887
            } else {
888
 
889
                return new JsonModel([
890
                    'success'   => false,
891
                    'data'      => 'ERROR_GROUP_REQUEST_COULD_NOT_BE_SENT'
892
                ]);
893
            }
894
        } else {
895
            return new JsonModel([
896
                'success' => false,
897
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
898
            ]);
899
        }
900
    }
901
 
902
    public function  groupMemberCancelAction()
903
    {
904
        $currentUserPlugin = $this->plugin('currentUserPlugin');
905
        $currentUser = $currentUserPlugin->getUser();
906
 
907
        $request = $this->getRequest();
908
        if ($request->isPost()) {
909
            $group_uuid = $this->params()->fromRoute('group_id');
910
            $user_uuid  = $this->params()->fromRoute('user_id');
911
 
912
            $groupMapper = GroupMapper::getInstance($this->adapter);
913
            $group = $groupMapper->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);
914
 
915
            if (!$group) {
916
                return new JsonModel([
917
                    'success' => false,
918
                    'data' => 'ERROR_GROUP_NOT_FOUND'
919
                ]);
920
            }
921
 
922
            if ($group->status != Group::STATUS_ACTIVE) {
923
                return new JsonModel([
924
                    'success' => false,
925
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
926
                ]);
927
            }
928
 
929
            if ($currentUser->id != $group->user_id) {
930
                return new JsonModel([
931
                    'success' => false,
932
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
933
                ]);
934
            }
935
 
936
            $userMapper = UserMapper::getInstance($this->adapter);
937
            $user = $userMapper->fetchOneByUuidAndNetworkId($user_uuid, $currentUser->network_id);
938
 
939
            if (!$user) {
940
                return new JsonModel([
941
                    'success' => false,
942
                    'data' => 'ERROR_USER_NOT_FOUND'
943
                ]);
944
            }
945
 
946
            if ($user->id == $currentUser->id) {
947
                return new JsonModel([
948
                    'success' => false,
949
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
950
                ]);
951
            }
952
 
953
 
954
 
955
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
956
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
957
            if ($groupMember) {
958
 
959
                if (
960
                    $groupMember->status == GroupMember::STATUS_ACCEPTED ||
961
                    $groupMember->status == GroupMember::STATUS_ADDED_BY_ADMIN ||
962
                    $groupMember->status == GroupMember::STATUS_AUTO_JOIN
963
                ) {
964
 
965
                    $groupMember->status = GroupMember::STATUS_CANCELLED;
966
                    if ($groupMemberMapper->update($groupMember)) {
967
 
968
                        return new JsonModel([
969
                            'success' => true,
970
                            'data' =>  'LABEL_GROUP_MEMBER_CANCELLED_SUCCESS'
971
                        ]);
972
                    } else {
973
                        return new JsonModel([
974
                            'success' => true,
975
                            'data' =>    'LABEL_GROUP_MEMBER_CANCELLED_FAILED'
976
                        ]);
977
                    }
978
                }
979
            }
980
 
981
 
982
            return new JsonModel([
983
                'success' => false,
984
                'data' => 'ERROR_GROUP_REQUEST_OR_MEMBER_NOT_FOUND_TO_CANCEL'
985
            ]);
986
        } else {
987
 
988
            return new JsonModel([
989
                'success' => false,
990
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
991
            ]);
992
        }
993
    }
994
 
995
    public function  groupMemberRejectAction()
996
    {
997
        $currentUserPlugin = $this->plugin('currentUserPlugin');
998
        $currentUser = $currentUserPlugin->getUser();
999
 
1000
        $request = $this->getRequest();
1001
        if ($request->isPost()) {
1002
            $group_uuid = $this->params()->fromRoute('group_id');
1003
            $user_uuid  = $this->params()->fromRoute('user_id');
1004
 
1005
            $groupMapper = GroupMapper::getInstance($this->adapter);
1006
            $group = $groupMapper->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);
1007
 
1008
            if (!$group) {
1009
                return new JsonModel([
1010
                    'success' => false,
1011
                    'data' => 'ERROR_GROUP_NOT_FOUND'
1012
                ]);
1013
            }
1014
 
1015
            if ($group->status != Group::STATUS_ACTIVE) {
1016
                return new JsonModel([
1017
                    'success' => false,
1018
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
1019
                ]);
1020
            }
1021
 
1022
            if ($currentUser->id != $group->user_id) {
1023
                return new JsonModel([
1024
                    'success' => false,
1025
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
1026
                ]);
1027
            }
1028
 
1029
            $userMapper = UserMapper::getInstance($this->adapter);
1030
            $user = $userMapper->fetchOneByUuidAndNetworkId($user_uuid, $currentUser->network_id);
1031
 
1032
            if (!$user) {
1033
                return new JsonModel([
1034
                    'success' => false,
1035
                    'data' => 'ERROR_USER_NOT_FOUND'
1036
                ]);
1037
            }
1038
 
1039
            if ($user->id == $currentUser->id) {
1040
                return new JsonModel([
1041
                    'success' => false,
1042
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
1043
                ]);
1044
            }
1045
 
1046
 
1047
 
1048
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
1049
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
1050
            if ($groupMember) {
1051
 
1052
                if ($groupMember->status == GroupMember::STATUS_JOINING_REQUESTED) {
1053
 
1054
                    $groupMember->status = GroupMember::STATUS_REJECTED;
1055
                    if ($groupMemberMapper->update($groupMember)) {
1056
 
1057
                        return new JsonModel([
1058
                            'success' => true,
1059
                            'data' =>  'LABEL_GROUP_MEMBER_REJECTED_SUCCESS'
1060
                        ]);
1061
                    } else {
1062
                        return new JsonModel([
1063
                            'success' => true,
1064
                            'data' =>    'LABEL_GROUP_MEMBER_REJECTED_FAILED'
1065
                        ]);
1066
                    }
1067
                }
1068
            }
1069
 
1070
 
1071
            return new JsonModel([
1072
                'success' => false,
1073
                'data' => 'ERROR_GROUP_THERE_IS_NO_PENDING_REQUEST_TO_REJECT'
1074
            ]);
1075
        } else {
1076
 
1077
            return new JsonModel([
1078
                'success' => false,
1079
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1080
            ]);
1081
        }
1082
    }
1083
 
1084
    public function  groupMemberApproveAction()
1085
    {
1086
        $currentUserPlugin = $this->plugin('currentUserPlugin');
1087
        $currentUser = $currentUserPlugin->getUser();
1088
 
1089
        $request = $this->getRequest();
1090
        if ($request->isPost()) {
1091
            $group_uuid = $this->params()->fromRoute('group_id');
1092
            $user_uuid  = $this->params()->fromRoute('user_id');
1093
 
1094
            $groupMapper = GroupMapper::getInstance($this->adapter);
1095
            $group = $groupMapper->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);
1096
 
1097
            if (!$group) {
1098
                return new JsonModel([
1099
                    'success' => false,
1100
                    'data' => 'ERROR_GROUP_NOT_FOUND'
1101
                ]);
1102
            }
1103
 
1104
            if ($group->status != Group::STATUS_ACTIVE) {
1105
                return new JsonModel([
1106
                    'success' => false,
1107
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
1108
                ]);
1109
            }
1110
 
1111
            if ($currentUser->id != $group->user_id) {
1112
                return new JsonModel([
1113
                    'success' => false,
1114
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
1115
                ]);
1116
            }
1117
 
1118
            $userMapper = UserMapper::getInstance($this->adapter);
1119
            $user = $userMapper->fetchOneByUuidAndNetworkId($user_uuid, $currentUser->network_id);
1120
 
1121
            if (!$user) {
1122
                return new JsonModel([
1123
                    'success' => false,
1124
                    'data' => 'ERROR_USER_NOT_FOUND'
1125
                ]);
1126
            }
1127
 
1128
            if ($user->id == $currentUser->id) {
1129
                return new JsonModel([
1130
                    'success' => false,
1131
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
1132
                ]);
1133
            }
1134
 
1135
 
1136
 
1137
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
1138
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
1139
            if ($groupMember) {
1140
 
1141
                if ($groupMember->status == GroupMember::STATUS_JOINING_REQUESTED) {
1142
 
1143
                    $groupMember->status = GroupMember::STATUS_ACCEPTED;
1144
                    if ($groupMemberMapper->update($groupMember)) {
1145
 
1146
 
1147
                        $notification = new Notification();
1148
                        $notification->type     = Notification::TYPE_ACCEPT_MY_REQUEST_JOIN_GROUP;
1149
                        $notification->read     = Notification::NO;
1150
                        $notification->user_id  = $user->id;
1151
                        $notification->group_id = $group->id;
1152
                        $notification->message  = 'LABEL_NOTIFICATION_ACCEPT_MY_REQUEST_JOIN_GROUP';
1153
                        $notification->url      = $this->url()->fromRoute('group/view', ['id' => $group->uuid]);
1154
 
1155
                        $notificationMapper = NotificationMapper::getInstance($this->adapter);
1156
                        $notificationMapper->insert($notification);
1157
 
1158
                        $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
1159
                        $userNotification = $userNotificationMapper->fetchOne($user->id);
1160
 
1161
                        if ($userNotification && $userNotification->receive_invitation_group) {
1162
                            $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
1163
                            $emailTemplate = $emailTemplateMapper->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_ACCEPT_MY_REQUEST_JOIN_GROUP, $currentUser->network_id);
1164
 
1165
                            if ($emailTemplate) {
1166
                                $arrayCont = [
1167
                                    'firstname'             => $currentUser->first_name,
1168
                                    'lastname'              => $currentUser->last_name,
1169
                                    'other_user_firstname'  => $user->first_name,
1170
                                    'other_user_lastname'   => $user->last_name,
1171
                                    'company_name'          => '',
1172
                                    'group_name'            => $group->name,
1173
                                    'content'               => '',
1174
                                    'code'                  => '',
1175
                                    'link'                  => $this->url()->fromRoute('group/view', ['id' => $group->uuid], ['force_canonical' => true])
1176
                                ];
1177
 
1178
                                $email = new QueueEmail($this->adapter);
1179
                                $email->processEmailTemplate($emailTemplate, $arrayCont, $user->email, trim($user->first_name . ' ' . $user->last_name));
1180
                            }
1181
                        }
1182
 
1183
                        return new JsonModel([
1184
                            'success' => true,
1185
                            'data' =>  'LABEL_GROUP_MEMBER_APPROVED_SUCCESS'
1186
                        ]);
1187
                    } else {
1188
                        return new JsonModel([
1189
                            'success' => true,
1190
                            'data' =>    'LABEL_GROUP_MEMBER_APPROVED_FAILED'
1191
                        ]);
1192
                    }
1193
                }
1194
            }
1195
 
1196
 
1197
            return new JsonModel([
1198
                'success' => false,
1199
                'data' => 'ERROR_GROUP_THERE_IS_NO_PENDING_REQUEST_TO_APPROVED'
1200
            ]);
1201
        } else {
1202
 
1203
            return new JsonModel([
1204
                'success' => false,
1205
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1206
            ]);
1207
        }
1208
    }
1209
 
1210
 
1211
    /**
1212
     * Recuperamos los grupos sugeridos
1213
     * tiene que enviarse un petición GET a la siguiente url: /helpers/groups-suggestion/:group_id
1214
     * retorna un json en caso de ser  positivo
1215
     * [
1216
     *  'success' : true,
1217
     *  'data' : [
1218
     *      [
1219
     *        'id'      => 'id del grupo encriptado',
1220
     *        'name'    => 'nombre del grupo',
1221
     *        'image'   => 'imagen del grupo',
1222
     *        'profile' => 'url del profile',
1223
     *     ]
1224
     * ]
1225
     * En caso de ser negativo
1226
     * [
1227
     *  'success' : false,
1228
     *  'data' : mensaje de error
1229
     * ]
1230
     * @return \Laminas\View\Model\JsonModel
1231
     */
1232
    public function groupsSuggestionAction()
1233
    {
1234
 
1235
        $request = $this->getRequest();
1236
        if ($request->isGet()) {
1237
 
1238
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1239
            $currentUser = $currentUserPlugin->getUser();
1240
 
1241
            $connectionMapper = ConnectionMapper::getInstance($this->adapter);
1242
            $first_degree_connections_ids = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
1243
            $first_degree_connections_ids = $first_degree_connections_ids ? $first_degree_connections_ids : [0];
1244
 
1245
            $second_degree_connections_ids = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
1246
            $second_degree_connections_ids = $second_degree_connections_ids ? $second_degree_connections_ids : [0];
1247
 
1248
            /*Usuarios de la empresas donde trabajo o soy dueño */
1249
            $company_user_ids = [];
1250
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1251
 
1252
            $records = $companyUserMapper->fetchAllByUserId($currentUser->id);
1253
            foreach ($records as $record) {
1254
 
1255
                if ($record->status != CompanyUser::STATUS_ACCEPTED) {
1256
                    continue;
1257
                }
1258
 
1259
                $otherUsers = $companyUserMapper->fetchAllByCompanyId($record->company_id);
1260
                foreach ($otherUsers as $otherUser) {
1261
                    if ($currentUser->id != $otherUser->user_id && $otherUser->creator == CompanyUser::CREATOR_NO && $otherUser->status == CompanyUser::STATUS_ACCEPTED) {
1262
 
1263
                        if (!in_array($otherUser->user_id, $company_user_ids)) {
1264
                            array_push($company_user_ids, $otherUser->user_id);
1265
                        }
1266
                    }
1267
                }
1268
            }
1269
            $company_user_ids =  $company_user_ids ? $company_user_ids : [0];
1270
 
1271
            /* Usuario de los grupos donde soy dueño o participo */
1272
 
1273
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
1274
 
1275
            $group_member_ids = [];
1276
 
1277
            $records = $groupMemberMapper->fetchAllByUserId($currentUser->id);
1278
            foreach ($records as $record) {
1279
                if ($record->status != GroupMember::STATUS_ACCEPTED) {
1280
                    continue;
1281
                }
1282
 
1283
                $otherUsers = $groupMemberMapper->fetchAllByGroupId($record->group_id);
1284
                foreach ($otherUsers as $otherUser) {
1285
                    if ($currentUser->id != $otherUser->user_id && $otherUser->status == GroupMember::STATUS_ACCEPTED) {
1286
 
1287
                        if (!in_array($otherUser->user_id, $group_member_ids)) {
1288
                            array_push($group_member_ids, $otherUser->user_id);
1289
                        }
1290
                    }
1291
                }
1292
            }
1293
 
1294
            $group_member_ids = $group_member_ids ? $group_member_ids : [0];
1295
 
1296
            /* Usuarios con que comparto capsulas */
1297
            $capsule_user_ids = [];
1298
            $capsuleUserMapper = CompanyMicrolearningCapsuleUserMapper::getInstance($this->adapter);
1299
 
1300
            $company_ids = [];
1301
            $records = $capsuleUserMapper->fetchAllActiveByUserId($currentUser->id);
1302
            foreach ($records as $record) {
1303
                if (!in_array($record->company_id, $company_ids)) {
1304
                    array_push($company_ids, $record->company_id);
1305
                }
1306
            }
1307
 
1308
            foreach ($company_ids as $company_id) {
1309
                $otherUsers = $capsuleUserMapper->fetchAllUserIdsForCapsulesActiveByCompanyId($company_id);
1310
                foreach ($otherUsers as $user_id) {
1311
                    if ($currentUser->id != $user_id) {
1312
 
1313
                        if (!in_array($user_id, $capsule_user_ids)) {
1314
                            array_push($capsule_user_ids, $user_id);
1315
                        }
1316
                    }
1317
                }
1318
            }
1319
 
1320
            $capsule_user_ids = $capsule_user_ids ? $capsule_user_ids : [0];
1321
 
1322
 
1323
            $other_users = array_unique(array_merge(
1324
 
1325
                $second_degree_connections_ids,
1326
                $company_user_ids,
1327
                $group_member_ids,
1328
                $capsule_user_ids
1329
            ));
1330
 
1331
            $queryMapper = QueryMapper::getInstance($this->adapter);
1332
 
1333
 
1334
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
1335
            $group_ids = $groupMemberMapper->fetchAllGroupIdsByUserIds($other_users);
1336
            $group_ids = $group_ids ? $group_ids : [0];
1337
 
1338
 
1339
 
1340
 
1341
            $select = $queryMapper->getSql()->select();
1342
            $select->columns(['id', 'uuid', 'name', 'image', 'status', 'privacy', 'priority' => new Expression('0')]);
1343
            $select->from(['g' => GroupMapper::_TABLE]);
1344
            $select->where->equalTo('network_id', $currentUser->network_id);
1345
            $select->where->equalTo('privacy', Group::PRIVACY_IS_PUBLIC);
1346
            $select->where->equalTo('status', Group::STATUS_ACTIVE);
1347
            $select->where->in('g.id', $group_ids);
1348
            $select->where->notEqualTo('g.user_id', $currentUser->id);
1349
            $select->order('name ASC');
1350
 
1351
 
1352
 
1353
            //echo $select->getSqlString($this->adapter->platform); exit;
1354
 
1355
            $records = $queryMapper->fetchAll($select);
1356
            usort($records, function ($a, $b) {
1357
                if ($a['priority'] == $b['priority']) {
1358
                    return 0;
1359
                } else {
1360
                    return $a['priority'] < $b['priority'] ? 1 : -1;
1361
                }
1362
            });
1363
 
1364
 
1365
            $items = [];
1366
 
1367
            foreach ($records as $record) {
1368
 
1369
                array_push($items, [
1370
                    'id'        => $record['uuid'],
1371
                    'name'      => trim($record['name']),
60 efrain 1372
                    'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'group', 'filename' => $record['image']],['force_canonical' => true],['force_canonical' => true]),
1 efrain 1373
                    'profile'   => $this->url()->fromRoute('group/view', ['id' => $record['uuid']]),
1374
                    'priority'  => $record['priority'],
1375
 
1376
                ]);
1377
            }
1378
 
1379
            return new JsonModel([
1380
                'success' => true,
1381
                'data' => $items
1382
            ]);
1383
        } else {
1384
            return new JsonModel([
1385
                'success' => false,
1386
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1387
            ]);
1388
        }
1389
    }
1390
 
1391
    public function postsAction()
1392
    {
1393
        $request = $this->getRequest();
1394
        if ($request->isGet()) {
1395
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1396
            $currentUser = $currentUserPlugin->getUser();
1397
 
1398
            $items = [];
1399
            $postMapper = PostMapper::getInstance($this->adapter);
1400
            $posts = $postMapper->fetchAllActiveByNetworkId($currentUser->network_id);
1401
 
1402
            //print_r($posts);
1403
 
1404
            foreach ($posts as $post) {
1405
                $dt = \DateTime::createFromFormat('Y-m-d', $post->date);
1406
                array_push($items, [
60 efrain 1407
                    'image' => $this->url()->fromRoute('storage', ['code' => $post->uuid, 'type' => 'post', 'filename' => $post->image],['force_canonical' => true]),
1 efrain 1408
                    'date' => $dt->format('d/m/Y'),
1409
                    'title' => $post->title,
1410
                    'link' => $this->url()->fromRoute('post', ['id' => $post->uuid]),
1411
                ]);
1412
            }
1413
 
1414
            return new JsonModel([
1415
                'success' => true,
1416
                'data' => $items
1417
            ]);
1418
        }
1419
 
1420
        return new JsonModel([
1421
            'success' => false,
1422
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
1423
        ]);
1424
    }
1425
 
1426
 
1427
 
1428
    public function searchPeopleAction()
1429
    {
1430
        $request = $this->getRequest();
1431
        if ($request->isGet()) {
1432
 
1433
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1434
            $currentUser = $currentUserPlugin->getUser();
1435
 
1436
            $search = Functions::sanitizeFilterString($this->params()->fromQuery('search'));
1437
            if (strlen($search) >= 3) {
1438
 
1439
 
1440
                $userMapper = UserMapper::getInstance($this->adapter);
1441
                $records  = $userMapper->fetchAllSuggestByNetworkIdAndSearch($currentUser->network_id, $search);
1442
 
1443
                $users = [];
1444
                foreach ($records as $record) {
1445
                    if ($currentUser->id == $record->id) {
1446
                        continue;
1447
                    }
1448
 
1449
 
1450
                    array_push($users, [
1451
                        'value' => $record->uuid,
1452
                        'text' => trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')'
1453
 
1454
                    ]);
1455
                }
1456
 
1457
                return new JsonModel([
1458
                    'success' => true,
1459
                    'data' => $users
1460
                ]);
1461
            } else {
1462
                return new JsonModel([
1463
                    'success' => true,
1464
                    'data' => []
1465
                ]);
1466
            }
1467
        } else {
1468
            return new JsonModel([
1469
                'success' => false,
1470
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1471
            ]);
1472
        }
1473
    }
1474
 
1475
    public function footerAction()
1476
    {
1477
        $request = $this->getRequest();
1478
        if ($request->isGet()) {
1479
 
1480
 
1481
            $links = isset($this->navigation['footer']) ?  $this->navigation['footer'] : [];
1482
 
1483
 
1484
            $data = [];
1485
            foreach ($links as $link) {
1486
                $data[$link['route']] = $link['label'];
1487
            }
1488
 
1489
 
1490
            return new JsonModel([
1491
                'success' => true,
1492
                'data' => $data,
1493
            ]);
1494
        } else {
1495
            return new JsonModel([
1496
                'success' => false,
1497
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1498
            ]);
1499
        }
1500
    }
1501
 
1502
 
1503
    /**
1504
     * Recuperamos los grupos sugeridos
1505
     * tiene que enviarse un petición GET a la siguiente url: /helpers/groups-suggestion/:group_id
1506
     * retorna un json en caso de ser  positivo
1507
     * [
1508
     *  'success' : true,
1509
     *  'data' : [
1510
     *      [
1511
     *        'id'      => 'id del grupo encriptado',
1512
     *        'name'    => 'nombre del grupo',
1513
     *        'image'   => 'imagen del grupo',
1514
     *        'profile' => 'url del profile',
1515
     *     ]
1516
     * ]
1517
     * En caso de ser negativo
1518
     * [
1519
     *  'success' : false,
1520
     *  'data' : mensaje de error
1521
     * ]
1522
     * @return \Laminas\View\Model\JsonModel
1523
     */
1524
    public function myGroupsAction()
1525
    {
1526
 
1527
        $request = $this->getRequest();
1528
        if ($request->isGet()) {
1529
 
1530
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1531
            $currentUser = $currentUserPlugin->getUser();
1532
 
1533
 
1534
            $queryMapper = QueryMapper::getInstance($this->adapter);
1535
            $select = $queryMapper->getSql()->select();
1536
            $select->columns(['id', 'uuid', 'name', 'image', 'status', 'privacy', 'priority' => new Expression('0')]);
1537
            $select->from(['g' => GroupMapper::_TABLE]);
1538
            $select->where->equalTo('status', Group::STATUS_ACTIVE);
1539
            $select->where->equalTo('g.user_id', $currentUser->id);
1540
            $select->order('name ASC');
1541
 
1542
 
1543
            $items = [];
1544
 
1545
            $records = $queryMapper->fetchAll($select);
1546
            foreach ($records as $record) {
1547
 
1548
                array_push($items, [
1549
                    'id'        => $record['uuid'],
1550
                    'name'      => trim($record['name']),
60 efrain 1551
                    'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'group', 'filename' => $record['image']],['force_canonical' => true]),
1 efrain 1552
                    'profile'   => $this->url()->fromRoute('group/view', ['id' => $record['uuid']]),
1553
                    'priority'  => $record['priority'],
1554
 
1555
                ]);
1556
            }
1557
 
1558
            return new JsonModel([
1559
                'success' => true,
1560
                'data' => $items
1561
            ]);
1562
        } else {
1563
            return new JsonModel([
1564
                'success' => false,
1565
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1566
            ]);
1567
        }
1568
    }
1569
 
1570
    public function nextEventsAction()
1571
    {
1572
        $request = $this->getRequest();
1573
        if ($request->isGet()) {
1574
 
1575
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1576
            $currentUser = $currentUserPlugin->getUser();
1577
 
1578
            $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
1579
            $currentNetwork = $currentNetworkPlugin->getNetwork();
1580
 
1581
 
1582
 
1583
            $dt = new \DateTime();
1584
            $dt->setTime(0, 0, 0);
1585
            $start = $dt->format('Y-m-d H:i:s');
1586
 
1587
            $dt->add(new \DateInterval('P30D'));
1588
            $dt->setTime(23, 59, 59);
1589
            $end = $dt->format('Y-m-d H:i:s');
1590
 
1591
 
1592
 
1593
 
1594
            $events = [];
1595
 
1596
 
1597
 
1598
            //3 días
1599
            $expirePeriod = 86400 * 3;
1600
            $t1 = time();
1601
 
1602
            $companies = [];
1603
            $companyMapper = CompanyMapper::getInstance($this->adapter);
1604
 
1605
            $companyUsers = [];
1606
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1607
            $records = $companyUserMapper->fetchAllByUserId($currentUser->id);
1608
 
1609
            foreach ($records as $record) {
1610
                $companyUsers[$record->company_id] = $record->backend == CompanyUser::BACKEND_YES;
1611
            }
1612
 
1613
 
1614
 
1615
            $zoomMeetingMapper = ZoomMeetingMapper::getInstance($this->adapter);
1616
            $recruitmentSelectionCandidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
1617
            $recruitmentSelectionVacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
1618
            $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
1619
            $performanceEvaluationTestMapper = PerformanceEvaluationTestMapper::getInstance($this->adapter);
1620
            $performanceEvaluationFormMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
1621
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
1622
            $userMapper = UserMapper::getInstance($this->adapter);
1623
 
1624
            $calendarEventMapper = CalendarEventMapper::getInstance($this->adapter);
1625
            $records = $calendarEventMapper->fetchAllByUserIdAndStartTimeAndEndTime($currentUser->id, $start, $end);
1626
            foreach ($records as $record) {
1627
                switch ($record->type) {
1628
 
1629
                    case CalendarEvent::TYPE_SURVEY_NORMAL:
1630
                        $backgroundColor = $currentNetwork->css_calendar_survey_bg_color;
1631
                        $textColor = $currentNetwork->css_calendar_survey_text_color;
1632
 
1633
                        $surveyTestMapper = SurveyTestMapper::getInstance($this->adapter);
1634
                        $surveyTest = $surveyTestMapper->fetchOne($record->relational_id);
1635
 
1636
                        if($surveyTest && $surveyTest->user_id == $currentUser->id) {
1637
 
1638
                            $surveyCampaingMapper = SurveyCampaignMapper::getInstance($this->adapter);
1639
                            $surveyCampaing = $surveyCampaingMapper->fetchOne($surveyTest->campaign_id);
1640
 
1641
                            $url = '';
1642
                            $hasLink = !empty($companyUsers[$surveyTest->company_id]);
1643
 
1644
                            if ($hasLink) {
1645
 
1646
                                if (!isset($companies[$surveyTest->company_id])) {
1647
                                    $company  = $companyMapper->fetchOne($surveyTest->company_id);
1648
 
1649
                                    $companies[$company->id]  = $company;
1650
                                } else {
1651
                                    $company = $companies[$surveyTest->company_id];
1652
                                }
1653
 
1654
 
1655
                                $url = $this->url()->fromRoute('backend/signin-company', [
1656
                                    'id' => $company->uuid,
1657
                                    'relational' => $surveyTest->uuid,
1658
                                    'type' => CalendarEvent::TYPE_SURVEY_ORGANIZATIONAL_CLIMATE,
136 efrain 1659
                                ], ['force_canonical' => true]);
1 efrain 1660
                            }
1661
 
1662
                            $dtStart = \DateTime::createFromFormat('Y-m-d', $surveyCampaing->end_date);
1663
 
1664
 
1665
                            array_push($events, [
1666
                                'id'                => $surveyTest->uuid,
1667
                                'title'             => $surveyCampaing->name,
146 efrain 1668
                                'start'             => $dtStart->format('Y-m-d'),
1 efrain 1669
                                'url'               => $url,
1670
                                'backgroundColor'   => $backgroundColor,
1671
                                'textColor'         => $textColor,
1672
                                'allDay'            => true,
1673
                                'type'              => 'task',
135 efrain 1674
                                'source'            => 'internal',
1 efrain 1675
                            ]);
1676
                        }
1677
 
1678
                        break;
1679
 
1680
                    case CalendarEvent::TYPE_SURVEY_ORGANIZATIONAL_CLIMATE:
1681
                        $backgroundColor = $currentNetwork->css_calendar_organizational_climate_bg_color;
1682
                        $textColor = $currentNetwork->css_calendar_organizational_climate_text_color;
1683
 
1684
                        $surveyTestMapper = SurveyTestMapper::getInstance($this->adapter);
1685
                        $surveyTest = $surveyTestMapper->fetchOne($record->relational_id);
1686
 
1687
                        if($surveyTest && $surveyTest->user_id == $currentUser->id) {
1688
 
1689
                            $surveyCampaingMapper = SurveyCampaignMapper::getInstance($this->adapter);
1690
                            $surveyCampaing = $surveyCampaingMapper->fetchOne($surveyTest->campaign_id);
1691
 
1692
                            $url = '';
1693
                            $hasLink = !empty($companyUsers[$surveyTest->company_id]);
1694
 
1695
                            if ($hasLink) {
1696
 
1697
                                if (!isset($companies[$surveyTest->company_id])) {
1698
                                    $company  = $companyMapper->fetchOne($surveyTest->company_id);
1699
 
1700
                                    $companies[$company->id]  = $company;
1701
                                } else {
1702
                                    $company = $companies[$surveyTest->company_id];
1703
                                }
1704
 
1705
 
1706
                                $url = $this->url()->fromRoute('backend/signin-company', [
1707
                                    'id' => $company->uuid,
1708
                                    'relational' => $surveyTest->uuid,
1709
                                    'type' => CalendarEvent::TYPE_SURVEY_ORGANIZATIONAL_CLIMATE,
136 efrain 1710
                                ], ['force_canonical' => true]);
1 efrain 1711
                            }
1712
 
1713
                            $dtStart = \DateTime::createFromFormat('Y-m-d', $surveyCampaing->end_date);
1714
 
1715
 
1716
                            array_push($events, [
1717
                                'id'                => $surveyTest->uuid,
1718
                                'title'             => $surveyCampaing->name,
146 efrain 1719
                                'start'             => $dtStart->format('Y-m-d'),
1 efrain 1720
                                'url'               => $url,
1721
                                'backgroundColor'   => $backgroundColor,
1722
                                'textColor'         => $textColor,
1723
                                'allDay'            => true,
1724
                                'type'              => 'task',
135 efrain 1725
                                'source'            => 'internal',
1 efrain 1726
                            ]);
1727
                        }
1728
 
1729
                        break;
1730
 
1731
 
1732
 
1733
 
1734
 
1735
 
1736
 
1737
 
1738
 
1739
 
1740
                    case CalendarEvent::TYPE_RECRUITMENT_SELECTION_INTERVIEW:
1741
                        $backgroundColor = $currentNetwork->css_calendar_recruitment_and_selection_bg_color;
1742
                        $textColor = $currentNetwork->css_calendar_recruitment_and_selection_text_color;
1743
 
1744
 
1745
                        $recruitmentSelectionInterview = $recruitmentSelectionInterviewMapper->fetchOne($record->relational_id);
1746
                        if ($recruitmentSelectionInterview) {
1747
                            $recruitmentSelectionVacancy = $recruitmentSelectionVacancyMapper->fetchOne($recruitmentSelectionInterview->vacancy_id);
1748
 
1749
                            $recruitmentSelectionCandidate = $recruitmentSelectionCandidateMapper->fetchOne($recruitmentSelectionInterview->candidate_id);
1750
                            if ($recruitmentSelectionVacancy && $recruitmentSelectionCandidate) {
1751
                                $jobDescription = $jobDescriptionMapper->fetchOne($recruitmentSelectionVacancy->job_description_id);
1752
                                if ($jobDescription) {
1753
                                    $url = '';
1754
                                    $hasLink = !empty($companyUsers[$recruitmentSelectionInterview->company_id]);
1755
 
1756
                                    if ($hasLink) {
1757
 
1758
                                        if (!isset($companies[$recruitmentSelectionInterview->company_id])) {
1759
                                            $company  = $companyMapper->fetchOne($recruitmentSelectionInterview->company_id);
1760
 
1761
                                            $companies[$company->id]  = $company;
1762
                                        } else {
1763
                                            $company = $companies[$recruitmentSelectionInterview->company_id];
1764
                                        }
1765
 
1766
 
1767
                                        $url = $this->url()->fromRoute('backend/signin-company', [
1768
                                            'id' => $company->uuid,
1769
                                            'relational' => $recruitmentSelectionInterview->uuid,
1770
                                            'type' => CalendarEvent::TYPE_RECRUITMENT_SELECTION_INTERVIEW
136 efrain 1771
                                        ], ['force_canonical' => true]);
1 efrain 1772
                                    }
1773
 
1774
                                    $dtStart = \DateTime::createFromFormat('Y-m-d', $recruitmentSelectionInterview->last_date);
1775
 
1776
 
1777
 
1778
 
1779
                                    array_push($events, [
1780
                                        'id'                => $recruitmentSelectionInterview->uuid,
1781
                                        'title'             => $recruitmentSelectionVacancy->name,
146 efrain 1782
                                        'start'             => $dtStart->format('Y-m-d'),
1 efrain 1783
                                        'url'               => $url,
1784
                                        'backgroundColor'   => $backgroundColor,
1785
                                        'textColor'         => $textColor,
1786
                                        'allDay'            => true,
1787
                                        'type'              => 'task',
135 efrain 1788
                                        'source'            => 'internal',
1 efrain 1789
                                    ]);
1790
                                }
1791
                            }
1792
                        }
1793
 
1794
 
1795
                        break;
1796
 
1797
                    case CalendarEvent::TYPE_PERFORMANCE_EVALUATION:
1798
 
1799
 
1800
                        $backgroundColor = $currentNetwork->css_calendar_performance_evaluation_bg_color;
1801
                        $textColor = $currentNetwork->css_calendar_performance_evaluation_text_color;
1802
 
1803
 
1804
                        $performanceEvaluationTest = $performanceEvaluationTestMapper->fetchOne($record->relational_id);
1805
                        if ($performanceEvaluationTest) {
1806
 
1807
                            $performanceEvaluationForm = $performanceEvaluationFormMapper->fetchOne($performanceEvaluationTest->form_id);
1808
                            if ($performanceEvaluationForm) {
1809
                                $jobDescription = $jobDescriptionMapper->fetchOne($performanceEvaluationForm->job_description_id);
1810
                                if ($jobDescription) {
1811
                                    $url = '';
1812
                                    $hasLink = !empty($companyUsers[$performanceEvaluationTest->company_id]);
1813
 
1814
                                    if ($performanceEvaluationTest->supervisor_id) {
1815
                                        $supervisor = $userMapper->fetchOne($performanceEvaluationTest->supervisor_id);
1816
                                    } else {
1817
                                        $supervisor = '';
1818
                                    }
1819
 
1820
                                    if ($performanceEvaluationTest->employee_id) {
1821
                                        $employee = $userMapper->fetchOne($performanceEvaluationTest->employee_id);
1822
                                    } else {
1823
                                        $employee = '';
1824
                                    }
1825
 
1826
 
1827
 
1828
                                    if ($hasLink) {
1829
 
1830
                                        if (!isset($companies[$performanceEvaluationTest->company_id])) {
1831
                                            $company  = $companyMapper->fetchOne($performanceEvaluationTest->company_id);
1832
 
1833
                                            $companies[$company->id]  = $company;
1834
                                        } else {
1835
                                            $company = $companies[$performanceEvaluationTest->company_id];
1836
                                        }
1837
 
1838
 
1839
                                        $url = $this->url()->fromRoute('backend/signin-company', [
1840
                                            'id' => $company->uuid,
1841
                                            'relational' => $performanceEvaluationTest->uuid,
1842
                                            'type' => CalendarEvent::TYPE_PERFORMANCE_EVALUATION
136 efrain 1843
                                        ], ['force_canonical' => true]);
1 efrain 1844
                                    }
1845
 
1846
                                    $dtStart = \DateTime::createFromFormat('Y-m-d', $performanceEvaluationTest->last_date);
1847
 
1848
                                    array_push($events, [
1849
                                        'id'                => $performanceEvaluationTest->uuid,
1850
                                        'title'             =>  $performanceEvaluationForm->name,
146 efrain 1851
                                        'start'             => $dtStart->format('Y-m-d'),
1 efrain 1852
                                        'url'               => $url,
1853
                                        'backgroundColor'   => $backgroundColor,
1854
                                        'textColor'         => $textColor,
1855
                                        'allDay'            => true,
1856
                                        'type'              => 'task',
135 efrain 1857
                                        'source'            => 'internal',
1 efrain 1858
                                    ]);
1859
                                }
1860
                            }
1861
                        }
1862
 
1863
 
1864
 
1865
 
1866
 
1867
                        break;
1868
 
1869
 
1870
                    case CalendarEvent::TYPE_ZOOM:
1871
                        $zoomMeeting = $zoomMeetingMapper->fetchOne($record->relational_id);
1872
                        if ($zoomMeeting) {
1873
 
1874
                            $backgroundColor = $currentNetwork->css_calendar_zoom_bg_color;
1875
                            $textColor = $currentNetwork->css_calendar_zoom_text_color;
1876
 
1877
                            $dtStart = \DateTime::createFromFormat('Y-m-d H:i:s', $zoomMeeting->start_time);
1878
                            $t2 = $dtStart->getTimestamp();
1879
 
1880
                            if ($t2 > $t1) {
1881
 
1882
                                $t3 = $t1 + $expirePeriod;
1883
                                if ($t3 > $t2) {
1884
                                    $backgroundColor = $currentNetwork->css_calendar_expire_bg_color;
1885
                                    $textColor = $currentNetwork->css_calendar_expire_text_color;
1886
                                }
1887
                            }
1888
 
1889
 
1890
 
1891
                            if ($currentUser->timezone && $currentUser->timezone != $zoomMeeting->timezone) {
1892
 
1893
                                $start =  str_replace(' ', 'T', Functions::convertDateTimeBetweenTimeZones($zoomMeeting->start_time, $zoomMeeting->timezone, $currentUser->timezone));
1894
                                $end =  str_replace(' ', 'T', Functions::convertDateTimeBetweenTimeZones($zoomMeeting->end_time, $zoomMeeting->timezone, $currentUser->timezone));
1895
                            } else {
1896
                                $start = str_replace(' ', 'T', $zoomMeeting->start_time);
1897
                                $end = str_replace(' ', 'T', $zoomMeeting->end_time);
1898
                            }
1899
 
1900
 
1901
 
1902
                            $url = $zoomMeeting->join_url;
1903
 
1904
 
1905
 
1906
 
1907
                            $agenda = $zoomMeeting->agenda . "<br>" .
1908
                                " LABEL_ZOOM_MEETING_START_DATE : " . $dtStart->format('Y-m-d') . "<br>" .
1909
                                " LABEL_ZOOM_MEETING_START_TIME : " . $dtStart->format('H:i a') . "<br>" .
1910
                                " LABEL_ZOOM_MEETING_TIMEZONE : " . $zoomMeeting->timezone . "<br>" .
1911
                                " LABEL_ZOOM_MEETING_TITLE :  " . $zoomMeeting->topic  . "<br>" .
1912
                                " LABEL_ZOOM_MEETING_URL : " . $zoomMeeting->join_url . "<br>" .
1913
                                " LABEL_ZOOM_MEETING_PASSWORD : " . $zoomMeeting->password . "<br>";
1914
 
1915
                            array_push($events, [
1916
                                'id'                => $zoomMeeting->id,
1917
                                'title'             => $zoomMeeting->topic,
1918
                                'agenda'            => $agenda,
1919
                                'start'             => $start,
1920
                                'end'               => $end,
1921
                                'url'               => $zoomMeeting->join_url,
1922
                                'backgroundColor'   => $backgroundColor,
1923
                                'textColor'         => $textColor,
135 efrain 1924
                                'type'              => 'event',
1925
                                'source'            => 'external',
1 efrain 1926
                            ]);
1927
                        }
1928
                        break;
1929
                }
1930
            }
1931
 
1932
 
1933
 
1934
            return new JsonModel([
1935
                'success' => true,
1936
                'data' => $events
1937
            ]);
1938
        } else {
1939
            return new JsonModel([
1940
                'success' => false,
1941
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1942
            ]);
1943
        }
1944
    }
1945
 
1946
    public function menuAction()
1947
    {
1948
 
1949
 
1950
        $request = $this->getRequest();
1951
 
1952
 
1953
 
1954
        if ($request->isGet()) {
1955
            $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
1956
            $network =  $currentNetworkPlugin->getNetwork();
1957
 
1958
 
1959
            $currentUserPlugin = $this->plugin('currentUserPlugin');
1960
            if($currentUserPlugin->hasIdentity()) {
1961
                $currentUser = $currentUserPlugin->getUser();
157 efrain 1962
 
1 efrain 1963
 
1964
 
1965
                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
1966
 
1967
                $link_admin         = $currentUser->usertype_id == UserType::ADMIN ? 1 : 0;
1968
                $link_impersonate   = $currentUser->is_super_user == User::IS_SUPER_USER_YES ? 1 : 0;
1969
                if($link_impersonate) {
1970
                    $url_impersonate = $this->url()->fromRoute('signin/impersonate');
1971
                } else {
1972
                    $url_impersonate = '';
1973
                }
1974
 
1975
                $fullname = trim($currentUser->first_name . ' ' . $currentUser->last_name);
1976
 
1977
                $profileVisitMapper = ProfileVisitMapper::getInstance($this->adapter);
1978
                $visits = $profileVisitMapper->getTotalByVisitedId($currentUser->id);
1979
 
1980
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
1981
                $connections = $connectionMapper->fetchTotalConnectionByUser($currentUser->id);
1982
 
1983
 
1984
                if($currentUser->location_id) {
1985
                    $locationMapper = LocationMapper::getInstance($this->adapter);
1986
                    $location = $locationMapper->fetchOne($currentUser->location_id);
1987
 
1988
                    $country = $location->country;
1989
                } else {
1990
                    $country = '';
1991
                }
1992
 
1993
 
1994
 
1995
 
1996
                if($currentUser->usertype_id == UserType::ADMIN) {
1997
                    $url_admin = $this->url()->fromRoute( 'backend/signin-admin');
1998
                } else {
1999
                    $url_admin = '';
2000
                }
2001
 
2002
 
2003
 
2004
                $link_company = '';
2005
                if($network->default != Network::DEFAULT_YES) {
2006
                    $companyMapper = CompanyMapper::getInstance($this->adapter);
2007
                    $company = $companyMapper->fetchDefaultForNetworkByNetworkId($network->id);
2008
                    if($company) {
2009
                        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
2010
                        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
2011
                        if($companyUser) {
2012
                            if($companyUser && $companyUser->status == CompanyUser::STATUS_ACCEPTED && $companyUser->backend == CompanyUser::BACKEND_YES ) {
2013
                                $link_company = ['route' => 'backend/signin-company', 'id' => $company->uuid ];
2014
                            }
2015
                        }
2016
                    }
157 efrain 2017
                } else {
2018
 
1 efrain 2019
                }
2020
 
167 efrain 2021
 
2022
 
2023
 
2024
 
1 efrain 2025
                if ($acl->isAllowed($currentUser->usertype_id,  'knowledge-area')) {
2026
                    $route_knowledge_area = $this->url()->fromRoute('knowledge-area');
2027
                    $link_knowledge_area = 1;
2028
                } else {
2029
 
2030
                    $route_knowledge_area = '';
2031
                    $link_knowledge_area = 0;
2032
                }
2033
 
2034
                if ($acl->isAllowed($currentUser->usertype_id,  'my-coach')) {
2035
                    $route_my_coach = $this->url()->fromRoute('my-coach');
2036
                    $link_my_coach = 1;
2037
                } else {
2038
 
2039
                    $route_my_coach = '';
2040
                    $link_my_coach = 0;
2041
                }
2042
 
2043
                if($network->default == Network::DEFAULT_YES) {
2044
                    if($network->relationship_user_mode == Network::RELATIONSHIP_USER_MODE_USER_2_USER)  {
2045
                        $pages = getAclMenuDefaultNetworkConnectionUser2User();
2046
                    } else {
2047
                        $pages = getAclMenuDefaultNetworkConnectionAll2All();
2048
                    }
2049
                } else {
2050
                    if($network->relationship_user_mode == Network::RELATIONSHIP_USER_MODE_USER_2_USER)  {
2051
 
2052
                        $pages = getAclMenuNonDefaulNetworkConnectionUser2User();
2053
 
2054
                    } else {
2055
                        $pages = getAclMenuNonDefaultNetworkConnectionAll2All();
2056
                    }
2057
                }
2058
 
2059
 
2060
                $menu = [];
2061
                foreach ($pages as $page) {
2062
 
2063
                    if (!$page || empty($page['route']) || !$acl->isAllowed($currentUser->usertype_id, $page['route'])) {
2064
                        continue;
2065
                    }
2066
 
2067
                    $ajax = false;
2068
                    if ($page['route'] == 'company' && $network->default == Network::DEFAULT_NO) {
2069
 
2070
                        if ($link_company) {
157 efrain 2071
                            $page['route'] = $this->url()->fromRoute($link_company['route'], ['id' => $link_company['id']]);
1 efrain 2072
                            $ajax = true;
2073
                        } else {
2074
                            continue;
2075
                        }
2076
                    }
2077
 
2078
                    $option = [
2079
                        'label' => $page['label'],
2080
                        'href' => $page['route'],
2081
                        'img' => empty($page['class']) ? '' : $page['class'],
2082
                        'ajax' => $ajax ? 1 : 0,
2083
                        'childs' => [],
2084
                    ];
2085
 
2086
                    $childs = empty($page['pages']) ? [] : $page['pages'];
2087
                    if ($childs) {
2088
                        foreach ($childs as $child) {
2089
                            if (!$acl->isAllowed($currentUser->usertype_id,  $child['route'])) {
2090
                                continue;
2091
                            }
2092
 
2093
                            $childs_level2 = [];
2094
 
2095
                            $childsLevel2 = empty($child['pages']) ? [] : $child['pages'];
2096
 
2097
                            if ($childsLevel2) {
2098
                                foreach ($childsLevel2 as $childLevel2) {
2099
                                    if (!$acl->isAllowed($currentUser->usertype_id,  $childLevel2['route'])) {
2100
                                        continue;
2101
                                    }
2102
 
2103
                                    array_push($childs_level2, [
2104
                                        'label' => $childLevel2['label'],
2105
                                        'href' => $childLevel2['route'],
2106
 
2107
                                    ]);
2108
                                }
2109
                            }
2110
 
2111
                            array_push($option['childs'], [
2112
                                'label' => $child['label'],
2113
                                'href' => $child['route'],
2114
                                'childs' => $childs_level2,
2115
                            ]);
2116
                        }
2117
                    }
2118
 
2119
                    array_push($menu, $option);
2120
                }
2121
 
2122
 
60 efrain 2123
                $image = $this->url()->fromRoute('storage', ['type' => 'user', 'code' => $currentUser->uuid, 'filename' => $currentUser->image],['force_canonical' => true]);
1 efrain 2124
                $isChatPage = $this->getEvent()->getViewModel()->getVariable('is_chat');
2125
                $routeCheckSession = $this->url()->fromRoute('check-session');
2126
 
2127
 
2128
 
2129
                return new JsonModel([
2130
                    'menu'                  => $menu,
2131
                    'isChatPage'            => $isChatPage == 1,
2132
                    'routeCheckSession'     => $routeCheckSession,
2133
                    'linkAdmin'             => $link_admin == 1,
2134
                    'urlAdmin'              => $url_admin,
2135
                    'linkImpersonate'       => $link_impersonate ==1 ,
2136
                    'urlImpersonate'        => $url_impersonate,
2137
                    'image'                 => $image,
2138
                    'fullName'              => $fullname,
2139
                    'country'               => $country,
2140
                    'visits'                => $visits,
2141
                    'connections'           => $connections,
2142
                    'logoForNavbar'         => 'https://' . $network->main_hostname . '/storage-network/type/navbar',
2143
                    'defaultNetwork'        => $network->default,
167 efrain 2144
                    //'linkKnowledgeArea'     => $link_knowledge_area == 1,
2145
                    //'routeKnowledgeArea'    => $route_knowledge_area,
2146
                    //'linkMyCoach'           => $link_my_coach == 1,
2147
                    //'routeMyCoach'          => $route_my_coach,
1 efrain 2148
               ]);
2149
 
2150
 
2151
 
2152
            }
2153
 
2154
 
2155
            return new JsonModel([
2156
                'menu'                  => [],
2157
                'isChatPage'            => false,
2158
                'routeCheckSession'     => '',
2159
                'linkAdmin'             => false,
2160
                'urlAdmin'              => '',
2161
                'linkImpersonate'       => false,
2162
                'urlImpersonate'        => '',
2163
                'image'                 => '',
2164
                'fullName'              => '',
2165
                'country'               => 0,
2166
                'visits'                => 0,
2167
                'connections'           => 0,
2168
                'logoForNavbar'         => 'https://' . $network->main_hostname . '/storage-network/type/navbar',
2169
                'defaultNetwork'        => $network->default,
2170
                'linkKnowledgeArea'     => false,
2171
                'routeKnowledgeArea'    => '',
2172
                'linkMyCoach'           => false,
2173
                'routeMyCoach'          => '',
2174
            ]);
2175
 
2176
        } else {
2177
 
2178
            return new JsonModel([
2179
                'success' => false,
2180
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
2181
            ]);
2182
        }
2183
 
2184
 
2185
        return new JsonModel([
2186
            'success' => false,
2187
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2188
        ]);
2189
    }
2190
 
2191
    public function companySizesAction()
2192
    {
2193
        $request = $this->getRequest();
2194
 
2195
 
2196
 
2197
        if ($request->isGet()) {
2198
            $items = [];
2199
 
2200
            $mapper = CompanySizeMapper::getInstance($this->adapter);
2201
            $records = $mapper->fetchAllActive();
2202
            foreach($records as $record)
2203
            {
2204
                 $items[ $record->uuid ] = $record->name;
2205
            }
2206
 
2207
            return new JsonModel([
2208
                'success' => true,
2209
                'data' => $items
2210
            ]);
2211
 
2212
 
2213
        }
2214
        return new JsonModel([
2215
            'success' => false,
2216
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2217
        ]);
2218
    }
2219
 
2220
    public function degreesAction()
2221
    {
2222
        $request = $this->getRequest();
2223
 
2224
 
2225
 
2226
        if ($request->isGet()) {
2227
            $items = [];
2228
 
2229
            $mapper = DegreeMapper::getInstance($this->adapter);
2230
            $records = $mapper->fetchAllActive();
2231
            foreach($records as $record)
2232
            {
2233
                $items[ $record->uuid ] = $record->name;
2234
            }
2235
 
2236
            return new JsonModel([
2237
                'success' => true,
2238
                'data' => $items
2239
            ]);
2240
 
2241
 
2242
        }
2243
        return new JsonModel([
2244
            'success' => false,
2245
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2246
        ]);
2247
    }
2248
 
2249
    public function languagesAction()
2250
    {
2251
        $request = $this->getRequest();
2252
 
2253
 
2254
 
2255
        if ($request->isGet()) {
2256
            $items = [];
2257
 
2258
            $mapper = LanguageMapper::getInstance($this->adapter);
2259
            $records = $mapper->fetchAllActive();
2260
            foreach($records as $record)
2261
            {
2262
                $items[ $record->id ] = $record->name;
2263
            }
2264
 
2265
            return new JsonModel([
2266
                'success' => true,
2267
                'data' => $items
2268
            ]);
2269
 
2270
 
2271
        }
2272
        return new JsonModel([
2273
            'success' => false,
2274
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2275
        ]);
2276
    }
2277
 
2278
    public function skillsAction()
2279
    {
2280
        $request = $this->getRequest();
2281
 
2282
 
2283
 
2284
        if ($request->isGet()) {
2285
            $items = [];
2286
 
2287
            $mapper = SkillMapper::getInstance($this->adapter);
2288
            $records = $mapper->fetchAllActive();
2289
            foreach($records as $record)
2290
            {
2291
                $items[ $record->uuid ] = $record->name;
2292
            }
2293
 
2294
            return new JsonModel([
2295
                'success' => true,
2296
                'data' => $items
2297
            ]);
2298
 
2299
 
2300
        }
2301
        return new JsonModel([
2302
            'success' => false,
2303
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2304
        ]);
2305
    }
2306
 
2307
 
2308
    public function aptitudesAction()
2309
    {
2310
        $request = $this->getRequest();
2311
 
2312
 
2313
 
2314
        if ($request->isGet()) {
2315
            $items = [];
2316
 
2317
            $mapper = AptitudeMapper::getInstance($this->adapter);
2318
            $records = $mapper->fetchAllActive();
2319
            foreach($records as $record)
2320
            {
2321
                $items[ $record->uuid ] = $record->name;
2322
            }
2323
 
2324
            return new JsonModel([
2325
                'success' => true,
2326
                'data' => $items
2327
            ]);
2328
 
2329
 
2330
        }
2331
        return new JsonModel([
2332
            'success' => false,
2333
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2334
        ]);
2335
    }
2336
 
2337
    public function hobbiesAction()
2338
    {
2339
        $request = $this->getRequest();
2340
 
2341
 
2342
 
2343
        if ($request->isGet()) {
2344
            $items = [];
2345
 
2346
            $mapper = HobbyAndInterestMapper::getInstance($this->adapter);
2347
            $records = $mapper->fetchAllActive();
2348
            foreach($records as $record)
2349
            {
2350
                $items[ $record->uuid ] = $record->name;
2351
            }
2352
 
2353
            return new JsonModel([
2354
                'success' => true,
2355
                'data' => $items
2356
            ]);
2357
 
2358
 
2359
        }
2360
        return new JsonModel([
2361
            'success' => false,
2362
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2363
        ]);
2364
    }
2365
 
2366
    public function industriesAction()
2367
    {
2368
        $request = $this->getRequest();
2369
 
2370
 
2371
 
2372
        if ($request->isGet()) {
2373
            $items = [];
2374
 
2375
            $mapper = IndustryMapper::getInstance($this->adapter);
2376
            $records = $mapper->fetchAllActive();
2377
            foreach($records as $record)
2378
            {
2379
                $items[ $record->uuid ] = $record->name;
2380
            }
2381
 
2382
            return new JsonModel([
2383
                'success' => true,
2384
                'data' => $items
2385
            ]);
2386
 
2387
 
2388
        }
2389
        return new JsonModel([
2390
            'success' => false,
2391
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2392
        ]);
2393
    }
2394
 
2395
    public function timeZonesAction() {
2396
 
2397
        $request = $this->getRequest();
2398
 
2399
 
2400
 
2401
        if ($request->isGet()) {
2402
            $items = [];
2403
 
2404
 
2405
            $records = Functions::getAllTimeZones();
2406
            foreach($records as $record)
2407
            {
2408
                $items[ $record ] = $record;
2409
            }
2410
 
2411
            return new JsonModel([
2412
                'success' => true,
2413
                'data' => $items
2414
            ]);
2415
 
2416
 
2417
        }
2418
        return new JsonModel([
2419
            'success' => false,
2420
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2421
        ]);
2422
 
2423
 
2424
 
2425
 
2426
 
2427
 
2428
    }
2429
 
117 efrain 2430
 
2431
    public function groupTypesAction()
2432
    {
2433
        $request = $this->getRequest();
2434
 
2435
 
2436
 
2437
        if ($request->isGet()) {
2438
            $items = [];
2439
 
2440
            $mapper = GroupTypeMapper::getInstance($this->adapter);
2441
            $records = $mapper->fetchAllActive();
2442
            foreach($records as $record)
2443
            {
2444
                $items[ $record->uuid ] = $record->name;
2445
            }
2446
 
2447
            return new JsonModel([
2448
                'success' => true,
2449
                'data' => $items
2450
            ]);
2451
 
2452
 
2453
        }
2454
        return new JsonModel([
2455
            'success' => false,
2456
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2457
        ]);
2458
    }
2459
 
2460
 
192 efrain 2461
    public function abuseReportAction()
2462
    {
2463
        $request = $this->getRequest();
2464
 
2465
        if ($request->isPost()) {
2466
 
2467
            $dataPost = $request->getPost()->toArray();
2468
 
2469
            $form = new CreateForm();
2470
            $form->setData($dataPost);
2471
 
2472
            if(!$form->isValid()) {
2473
                $messages = [];
2474
 
2475
 
2476
 
2477
                $form_messages = (array) $form->getMessages();
2478
                foreach($form_messages  as $fieldname => $field_messages)
2479
                {
2480
 
2481
                    $messages[$fieldname] = array_values($field_messages);
2482
                }
2483
 
2484
                return new JsonModel([
2485
                    'success'   => false,
2486
                    'data'   => $messages
2487
                ]);
2488
 
2489
            }
2490
 
2491
            $dataPost = (array) $form->getData();
1 efrain 2492
 
192 efrain 2493
            $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
2494
            $network =  $currentNetworkPlugin->getNetwork();
2495
 
2496
 
2497
            $currentUserPlugin = $this->plugin('currentUserPlugin');
2498
            $currentUser = $currentUserPlugin->getUser();
2499
 
2500
            $id     = $this->params()->fromRoute('id');
2501
            $type   = $this->params()->fromRoute('type');
2502
 
2503
            $blockUser = $dataPost['block_user'] == 'y';
2504
 
2505
            $abuseReport = new AbuseReport();
2506
            $abuseReport->network_id = $network->id;
2507
            $abuseReport->user_reporting_id = $currentUser->id;
2508
            $abuseReport->status = AbuseReport::STATUS_PENDING;
2509
            $abuseReport->comment = $dataPost['comment'];
2510
            $abuseReport->reason = $dataPost['reason'];
2511
 
2512
 
2513
 
2514
 
2515
            switch($type)
2516
            {
2517
                case 'feed' :
2518
                    $feedMapper = FeedMapper::getInstance($this>adapter);
2519
                    $feed = $feedMapper->fetchOneByUuid($id);
2520
                    if(!$feed || $feed->status != Feed::STATUS_PUBLISHED || $feed->network_id != $network->id) {
2521
 
2522
                        return new JsonModel([
2523
                            'success' => false,
2524
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2525
                        ]);
2526
                    }
2527
 
2528
                    if($feed->user_id == 1) {
2529
                        return new JsonModel([
2530
                            'success' => false,
2531
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2532
                        ]);
2533
                    }
2534
 
2535
                    if($feed->user_id == $currentUser->id) {
2536
                        return new JsonModel([
2537
                            'success' => false,
2538
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_IS_YOURSELF'
2539
                        ]);
2540
                    }
2541
 
2542
                    $abuseReport->related_id        =  $feed->id;
2543
                    $abuseReport->user_reported_id  = $feed->user_id;
2544
                    $abuseReport->type              = AbuseReport::TYPE_FEED;
2545
 
2546
 
2547
 
2548
                    break;
2549
 
2550
                case 'post' :
2551
                    $postMapper = PostMapper::getInstance($this->adapter);
2552
                    $post = $postMapper->fetchOneByUuid($id);
2553
                    if(!$post || $post->status != Post::STATUS_ACTIVE || $post->network_id != $network->id) {
2554
 
2555
                        return new JsonModel([
2556
                            'success' => false,
2557
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2558
                        ]);
2559
                    }
2560
 
2561
                    if($post->user_id == 1) {
2562
                        return new JsonModel([
2563
                            'success' => false,
2564
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2565
                        ]);
2566
                    }
2567
 
2568
 
2569
                    if($post->user_id == $currentUser->id) {
2570
                        return new JsonModel([
2571
                            'success' => false,
2572
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_IS_YOURSELF'
2573
                        ]);
2574
                    }
2575
 
2576
 
2577
                    $abuseReport->related_id        = $post->id;
2578
                    $abuseReport->user_reported_id  = $post->user_id;
2579
                    $abuseReport->type              = AbuseReport::TYPE_POST;
2580
 
2581
                    break;
2582
 
2583
 
2584
                case 'comment' :
2585
                    $commentMapper = CommentMapper::getInstance($this->adapter);
2586
                    $comment = $commentMapper->fetchOneByUuid($id);
2587
                    if(!$comment || $comment->network_id != $network->id || $comment->status != Comment::STATUS_PUBLISHED) {
2588
 
2589
                        return new JsonModel([
2590
                            'success' => false,
2591
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2592
                        ]);
2593
                    }
2594
 
2595
                    if($comment->user_id == 1) {
2596
                        return new JsonModel([
2597
                            'success' => false,
2598
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2599
                        ]);
2600
                    }
2601
 
2602
                    if($comment->user_id == $currentUser->id) {
2603
                        return new JsonModel([
2604
                            'success' => false,
2605
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_IS_YOURSELF'
2606
                        ]);
2607
                    }
2608
 
2609
                    $abuseReport->related_id        = $comment->id;
2610
                    $abuseReport->user_reported_id  = $comment->user_id;
2611
                    $abuseReport->type              = AbuseReport::TYPE_COMMENT;
2612
 
2613
                    break;
2614
 
2615
 
2616
                case 'message' :
2617
                    $messageMapper = MessageMapper::getInstance($this->adapter);
2618
                    $message = $messageMapper->fetchOneByUuid($id);
2619
                    if(!$message || $message->receiver_id != $currentUser->id || $message->receiver_status != Message::STATUS_NORMAL) {
2620
 
2621
                        return new JsonModel([
2622
                            'success' => false,
2623
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2624
                        ]);
2625
                    }
2626
 
2627
                    if($message->sender_id == 1) {
2628
                        return new JsonModel([
2629
                            'success' => false,
2630
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2631
                        ]);
2632
                    }
2633
 
2634
                    $abuseReport->related_id        = $message->id;
2635
                    $abuseReport->user_reported_id  = $message->sender_id;
2636
                    $abuseReport->type              = AbuseReport::TYPE_INMAIL_MESSAGE;
2637
 
2638
                    break;
2639
 
2640
                case 'chat-message' :
2641
                    $messageMapper = ChatMessageMapper::getInstance($this->adapter);
2642
                    $message = $messageMapper->fetchOneByUuid($id);
2643
                    if(!$message || $message->to_id != $currentUser->id || $message->status != ChatMessage::STATUS_PUBLISHED) {
2644
 
2645
                        return new JsonModel([
2646
                            'success' => false,
2647
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2648
                        ]);
2649
                    }
2650
 
2651
                    if($message->from_id == 1) {
2652
                        return new JsonModel([
2653
                            'success' => false,
2654
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2655
                        ]);
2656
                    }
2657
 
2658
                    $abuseReport->related_id        = $message->id;
2659
                    $abuseReport->user_reported_id  = $message->from_id;
2660
                    $abuseReport->type              = AbuseReport::TYPE_CHAT_USER_MESSAGE;
2661
 
2662
                    break;
2663
 
2664
                case 'chat-group-message' :
2665
                    $messageMapper = ChatGroupMessageMapper::getInstance($this->adapter);
2666
                    $message = $messageMapper->fetchOne($id);
2667
                    if(!$message || $message->status != ChatMessage::STATUS_PUBLISHED) {
2668
 
2669
                        return new JsonModel([
2670
                            'success' => false,
2671
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2672
                        ]);
2673
                    }
2674
 
2675
                    $userMessageMapper = ChatGroupUserMessageMapper::getInstance($this->adapter);
2676
                    $userMessage = $userMessageMapper->fetchOneByIdMessageIdAndReceiverId($message->id, $currentUser->id);
2677
                    if(!$userMessage) {
2678
 
2679
                        return new JsonModel([
2680
                            'success' => false,
2681
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_NOT_AVAILABLE'
2682
                        ]);
2683
                    }
2684
 
2685
 
2686
                    if($message->sender_id == 1) {
2687
                        return new JsonModel([
2688
                            'success' => false,
2689
                            'data' => 'ERROR_ABUSE_REPORT_CONTENT_OWNER_SYSADMIN'
2690
                        ]);
2691
                    }
2692
 
2693
                    $abuseReport->related_id        = $message->id;
2694
                    $abuseReport->user_reported_id  = $message->sender_id;
2695
                    $abuseReport->type              = AbuseReport::TYPE_CHAT_USER_MESSAGE;
2696
 
2697
                    break;
2698
            }
2699
 
2700
            $abuseReportMapper = AbuseReportMapper::getInstance($this->adapter);
2701
            if($abuseReportMapper->insert($abuseReport)) {
2702
 
2703
                if($blockUser) {
2704
 
2705
                    $userBlockedMapper = UserBlockedMapper::getInstance($this->adapter);
2706
                    $userBlocked = $userBlockedMapper->fetchOneByUserIdAndBlockedId($abuseReport->user_reporting_id, $abuseReport->user_reporting_id);
2707
                    if($userBlocked) {
2708
 
2709
 
2710
                        return new JsonModel([
2711
                            'success' => true,
2712
                            'data' => [
2713
                                'message' => 'LABEL_ABUSE_REPORT_SENT_WITH_BLOCK_USER',
2714
                                'block' => true
2715
                            ]
2716
                        ]);
2717
 
2718
                    } else {
2719
 
2720
                        $userBlocked = new UserBlocked();
2721
                        $userBlocked->user_id = $abuseReport->user_reporting_id;
2722
                        $userBlocked->blocked_id = $abuseReport->user_reported_id;
2723
 
2724
                        if($userBlockedMapper->insert($userBlocked)) {
2725
                            return new JsonModel([
2726
                                'success' => true,
2727
                                'data' => [
2728
                                    'message' => 'LABEL_ABUSE_REPORT_SENT_WITH_BLOCK_USER',
2729
                                    'block' => true
2730
                                ]
2731
                            ]);
2732
 
2733
                        } else {
2734
                            return new JsonModel([
2735
                                'success' => true,
2736
                                'data' => [
2737
                                    'message' => 'LABEL_ABUSE_REPORT_SENT_WITHOUT_BLOCK_USER',
2738
                                    'block' => false
2739
                                ]
2740
                            ]);
2741
 
2742
 
2743
                        }
2744
                    }
2745
 
2746
 
2747
                } else {
2748
                    return new JsonModel([
2749
                        'success' => true,
2750
                        'data' => [
2751
                            'message' => 'LABEL_ABUSE_REPORT_SENT_WITHOUT_BLOCK_USER',
2752
                            'block' => false
2753
                        ]
2754
                    ]);
2755
                }
2756
 
2757
 
2758
            } else {
2759
                return new JsonModel([
2760
                    'success' => false,
2761
                    'data' => 'ERROR_ABUSE_REPORT_NOT_SENT'
2762
                ]);
2763
            }
2764
 
2765
 
2766
 
2767
 
2768
 
2769
 
2770
 
2771
 
2772
        }
2773
        return new JsonModel([
2774
            'success' => false,
2775
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
2776
        ]);
2777
 
2778
 
2779
    }
2780
 
2781
 
2782
 
1 efrain 2783
}