Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

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

Rev Autor Línea Nro. Línea
1 www 1
<?php
2
/**
3
 *
4
 * Controlador: Mis Perfiles
5
 *
6
 */
7
declare(strict_types=1);
8
 
9
namespace LeadersLinked\Controller;
10
 
11
use Laminas\Db\Adapter\AdapterInterface;
12
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
13
use Laminas\Mvc\Controller\AbstractActionController;
14
use Laminas\Log\LoggerInterface;
15
use Laminas\View\Model\JsonModel;
16
 
17
use LeadersLinked\Library\Functions;
18
use LeadersLinked\Mapper\CompanyUserMapper;
19
use LeadersLinked\Form\Feed\CreateForm;
20
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
21
use LeadersLinked\Model\Feed;
22
use LeadersLinked\Mapper\FeedMapper;
23
use LeadersLinked\Library\Image;
24
use LeadersLinked\Mapper\GroupMapper;
25
use LeadersLinked\Mapper\UserMapper;
26
use LeadersLinked\Mapper\CommentMapper;
27
use LeadersLinked\Mapper\ConnectionMapper;
28
use LeadersLinked\Mapper\CompanyFollowerMapper;
29
use LeadersLinked\Mapper\QueryMapper;
30
use Laminas\Paginator\Paginator;
31
use Laminas\Paginator\Adapter\DbSelect;
32
use LeadersLinked\Mapper\LikeMapper;
33
use LeadersLinked\Model\Like;
34
use LeadersLinked\Form\Feed\CommentForm;
35
use LeadersLinked\Model\Comment;
36
use LeadersLinked\Form\Feed\CreateGroupCompanyForm;
37
use LeadersLinked\Model\CompanyUser;
38
use LeadersLinked\Model\VideoConvert;
39
use LeadersLinked\Mapper\VideoConvertMapper;
40
use LeadersLinked\Mapper\CompanyMapper;
41
use LeadersLinked\Model\Company;
42
use LeadersLinked\Model\Group;
43
use LeadersLinked\Mapper\GroupMemberMapper;
44
use LeadersLinked\Model\GroupMember;
45
use LeadersLinked\Model\Notification;
46
use LeadersLinked\Mapper\NotificationMapper;
47
use LeadersLinked\Mapper\UserNotificationSettingMapper;
48
use LeadersLinked\Mapper\EmailTemplateMapper;
49
use LeadersLinked\Model\EmailTemplate;
50
use LeadersLinked\Library\QueueEmail;
51
 
52
 
53
class FeedController extends AbstractActionController
54
{
55
    /**
56
     *
57
     * @var AdapterInterface
58
     */
59
    private $adapter;
60
 
61
 
62
    /**
63
     *
64
     * @var AbstractAdapter
65
     */
66
    private $cache;
67
 
68
    /**
69
     *
70
     * @var  LoggerInterface
71
     */
72
    private $logger;
73
 
74
 
75
    /**
76
     *
77
     * @var array
78
     */
79
    private $config;
80
 
81
    /**
82
     *
83
     * @param AdapterInterface $adapter
84
     * @param AbstractAdapter $cache
85
     * @param LoggerInterface $logger
86
     * @param array $config
87
     */
88
    public function __construct($adapter, $cache , $logger,  $config)
89
    {
90
        $this->adapter      = $adapter;
91
        $this->cache        = $cache;
92
        $this->logger       = $logger;
93
        $this->config       = $config;
94
 
95
    }
96
 
97
    /**
98
     *
99
     * Generación del listado de perfiles
100
     * {@inheritDoc}
101
     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
102
     */
103
    public function indexAction()
104
    {
105
 
106
        return new JsonModel([
107
            'success' => false,
108
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
109
        ]);
110
    }
111
 
112
    public function commentAction()
113
    {
114
        $id = $this->params()->fromRoute('id');
115
 
116
        $request = $this->getRequest();
117
        if($request->isPost()) {
118
            $feedMapper = FeedMapper::getInstance($this->adapter);
119
            $feed = $feedMapper->fetchOneByUuid($id);
120
            if(!$feed) {
121
                $response = [
122
                    'success' => false,
123
                    'data' => 'ERROR_POST_NOT_FOUND'
124
                ];
125
                return new JsonModel($response);
126
            }
127
 
128
            $dataPost = $request->getPost()->toArray();
129
            $form = new CommentForm();
130
            $form->setData($dataPost);
131
 
132
            if($form->isValid()) {
133
                $currentUserPlugin = $this->plugin('currentUserPlugin');
134
                $currentUser = $currentUserPlugin->getUser();
135
 
136
                $dataPost = (array) $form->getData();
137
 
138
                $comment = new Comment();
139
                $comment->comment = $dataPost['comment'];
140
                $comment->user_id = $currentUser->id;
141
                $comment->feed_id = $feed->id;
142
 
143
                $commentMapper = CommentMapper::getInstance($this->adapter);
144
                if($commentMapper->insert($comment)) {
145
 
146
 
147
                    if($feed->type == Feed::TYPE_UPDATE) {
148
                        $userMapper = UserMapper::getInstance($this->adapter);
149
                        $ownerFeed = $userMapper->fetchOne($feed->user_id);
150
 
151
                        $notification = new Notification();
152
                        $notification->type = Notification::TYPE_COMMENT_MY_FEED;
153
                        $notification->feed_id = $feed->id;
154
                        $notification->read     = Notification::NO;
155
                        $notification->user_id  = $ownerFeed->id;
156
                        $notification->message  = 'LABEL_COMMENT_MY_FEED';
157
                        $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $feed->uuid]);
158
 
159
                        $notificationMapper = NotificationMapper::getInstance($this->adapter);
160
                        $notificationMapper->insert($notification);
161
 
162
                        $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
163
                        $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
164
 
165
                        if($userNotification && $userNotification->comment_my_feed)
166
                        {
167
                            $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
168
                            $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_COMMENT_MY_FEED);
169
 
170
                            if($emailTemplate) {
171
                                $arrayCont = [
172
                                    'firstname'             => $currentUser->first_name,
173
                                    'lastname'              => $currentUser->last_name,
174
                                    'other_user_firstname'  => $ownerFeed->first_name,
175
                                    'other_user_lastname'   => $ownerFeed->last_name,
176
                                    'company_name'          => '',
177
                                    'group_name'            => '',
178
                                    'content'               => '',
179
                                    'code'                  => '',
180
                                    'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
181
                                ];
182
 
183
                                $email = new QueueEmail($this->adapter);
184
                                $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
185
                            }
186
                        }
187
                    }
188
 
189
                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
190
 
191
                    $feed->total_comments = $total_comments;
192
                    $feedMapper->update($feed);
193
 
194
                    $response = [
195
                        'success'   => true,
196
                        'data'   => $this->renderComment($comment->id),
197
                        'total_comments' => $total_comments
198
                    ];
199
 
200
                    return new JsonModel($response);
201
 
202
                } else {
203
 
204
                    $response = [
205
                        'success'   => false,
206
                        'data'   => $commentMapper->getError()
207
                    ];
208
 
209
                    return new JsonModel($response);
210
                }
211
 
212
            } else {
213
                $message = '';;
214
                $form_messages = (array) $form->getMessages();
215
                foreach($form_messages  as $fieldname => $field_messages)
216
                {
217
                    foreach( $field_messages as $key => $value)
218
                    {
219
                        $message = $value;
220
                    }
221
                }
222
 
223
                $response = [
224
                    'success'   => false,
225
                    'data'   => $message
226
                ];
227
 
228
                return new JsonModel($response);
229
            }
230
 
231
 
232
        } else {
233
            $response = [
234
                'success' => false,
235
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
236
            ];
237
 
238
            return new JsonModel($response);
239
        }
240
 
241
 
242
    }
243
 
244
    public function shareAction()
245
    {
246
        $id = $this->params()->fromRoute('id');
247
 
248
        $request = $this->getRequest();
249
        if($request->isPost()) {
250
            $feedMapper = FeedMapper::getInstance($this->adapter);
251
            $feed = $feedMapper->fetchOneByUuid($id);
252
            if(!$feed) {
253
                $response = [
254
                    'success' => false,
255
                    'data' => 'ERROR_POST_NOT_FOUND'
256
                ];
257
                return new JsonModel($response);
258
            }
259
 
260
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
261
            $dataPost['company_id'] = $this->params()->fromRoute('company_id');
262
            $dataPost['group_id'] = $this->params()->fromRoute('group_id');
263
            $dataPost['shared_feed_id'] = $feed->id;
264
 
265
 
266
 
267
 
268
            $response = $this->postOrShareFeed($dataPost);
269
            if( $response ['success']) {
270
                $feedMapper->incTotalShared($feed->id);
271
                $total_shared = $feedMapper->fetchTotalShared($feed->id);
272
 
273
                $response['total_shared'] = $total_shared;
274
            }
275
 
276
 
277
            return new JsonModel($response);
278
 
279
        } else {
280
            $response = [
281
                'success' => false,
282
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
283
            ];
284
        }
285
 
286
        return new JsonModel($response);
287
    }
288
 
289
    public function commentDeleteAction()
290
    {
291
        $request = $this->getRequest();
292
        if($request->isPost()) {
293
            $currentUserPlugin = $this->plugin('currentUserPlugin');
294
            $currentUser = $currentUserPlugin->getUser();
295
 
296
            $feed_id = $this->params()->fromRoute('id');
297
            $comment = $this->params()->fromRoute('comment');
298
 
299
            $feedMapper = FeedMapper::getInstance($this->adapter);
300
            $feed = $feedMapper->fetchOneByUuid($feed_id);
301
 
302
            if($feed) {
303
 
304
                $commentMapper = CommentMapper::getInstance($this->adapter);
305
                $comment = $commentMapper->fetchOneByUuid($comment);
306
 
307
                if($comment && $comment->feed_id == $feed->id && $comment->user_id == $currentUser->id) {
308
 
309
                    $comment->status = Comment::STATUS_DELETED;
310
 
311
                    if($commentMapper->update($comment)) {
312
 
313
                        $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
314
 
315
 
316
                        $feedMapper = FeedMapper::getInstance($this->adapter);
317
                        $feed = $feedMapper->fetchOne($comment->feed_id);
318
                        $feed->total_comments = $total_comments;
319
                        $feedMapper->update($feed);
320
 
321
 
322
 
323
 
324
 
325
                        $response = [
326
                            'success' => true,
327
                            'data' => 'LABEL_COMMENT_WAS_DELETED',
328
                            'total_comments' => $total_comments
329
                        ];
330
 
331
                    } else {
332
                        $response = [
333
                            'success' => false,
334
                            'data' => $commentMapper->getError()
335
                        ];
336
                    }
337
 
338
                } else {
339
                    $response = [
340
                        'success' => false,
341
                        'data' => 'ERROR_COMMENT_NOT_FOUND'
342
                    ];
343
                }
344
            } else {
345
                $response = [
346
                    'success' => false,
347
                    'data' => 'ERROR_COMMENT_NOT_FOUND'
348
                ];
349
            }
350
        } else {
351
            $response = [
352
                'success' => false,
353
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
354
            ];
355
        }
356
 
357
        return new JsonModel($response);
358
    }
359
 
360
    public function deleteAction()
361
    {
362
        $request = $this->getRequest();
363
        if($request->isPost()) {
364
            $currentUserPlugin = $this->plugin('currentUserPlugin');
365
            $currentUser = $currentUserPlugin->getUser();
366
 
367
            $feed_id =  $this->params()->fromRoute('id');
368
 
369
            $feedMapper = FeedMapper::getInstance($this->adapter);
370
            $feed = $feedMapper->fetchOneByUuid($feed_id);
371
 
372
            if($feed) {
373
 
374
                if($feed->user_id && $feed->user_id == $currentUser->id) {
375
 
376
                    return new JsonModel($this->deleteFeed($feed));
377
                } else if ($feed->group_id) {
378
 
379
                    $groupMapper = GroupMapper::getInstance($this->adapter);
380
                    $group = $groupMapper->fetchOne($feed->group_id);
381
                    if($group && $group->user_id == $currentUser->id) {
382
                        return new JsonModel($this->deleteFeed($feed));
383
                    }
384
 
385
                } else if ($feed->company_id) {
386
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
387
                    $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($feed->company_id, $currentUser->id);
388
                    if($companyUser) {
389
                        if(in_array($companyUser->type, [CompanyUser::TYPE_OWNER, CompanyUser::TYPE_ADMINISTRATOR, CompanyUser::TYPE_MANAGER])) {
390
                            return new JsonModel($this->deleteFeed($feed));
391
                        }
392
                    }
393
                }
394
 
395
                $response = [
396
                    'success' => false,
397
                    'data' => ' ERROR_UNAUTHORIZED'
398
                ];
399
 
400
 
401
            } else {
402
                $response = [
403
                    'success' => false,
404
                    'data' => 'ERROR_FEED_NOT_FOUND'
405
                ];
406
            }
407
 
408
            return new JsonModel($response);
409
 
410
        } else {
411
            $response = [
412
                'success' => false,
413
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
414
            ];
415
        }
416
 
417
        return new JsonModel($response);
418
    }
419
 
420
    public function addAction()
421
    {
422
        $request = $this->getRequest();
423
        if($request->isPost()) {
424
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
425
            $dataPost['company_id'] = $this->params()->fromRoute('company_id');
426
            $dataPost['group_id'] = $this->params()->fromRoute('group_id');
402 geraldo 427
 
403 geraldo 428
            //return new JsonModel($dataPost);
402 geraldo 429
 
1 www 430
            $response = $this->postOrShareFeed($dataPost);
431
 
432
 
433
            return new JsonModel($response);
434
 
435
        } else {
436
            $response = [
437
                'success' => false,
438
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
439
            ];
440
        }
441
 
442
        return new JsonModel($response);
443
    }
444
 
445
    public function postOrShareFeed($dataPost)
446
    {
447
        $currentUserPlugin = $this->plugin('currentUserPlugin');
448
        $currentUser = $currentUserPlugin->getUser();
449
 
450
        $companyId  = empty($dataPost['company_id']) ? '' : $dataPost['company_id'];
451
        $groupId    = empty($dataPost['group_id']) ? '' : $dataPost['group_id'];
452
 
453
 
454
        if($groupId || $companyId) {
455
            $form = new  CreateGroupCompanyForm($this->adapter);
456
        } else {
457
            $form = new  CreateForm($this->adapter);
458
        }
459
        $form->setData($dataPost);
404 geraldo 460
 
461
 
462
 
1 www 463
        if($form->isValid()) {
464
 
404 geraldo 465
            return new JsonModel($form);
1 www 466
 
404 geraldo 467
 
1 www 468
            $hydrator = new ObjectPropertyHydrator();
469
            $feed = new Feed();
470
            $hydrator->hydrate($dataPost, $feed);
471
 
472
            $company = null;
473
            $group = null;
474
 
475
            if($companyId) {
476
                $companyMapper = CompanyMapper::getInstance($this->adapter);
477
                $company = $companyMapper->fetchOneByUuid($companyId);
478
 
479
 
480
                if(!$company) {
481
                    return [
482
                        'success'   => false,
483
                        'data'   => 'ERROR_COMPANY_NOT_FOUND'
484
                    ];
485
                }
486
 
487
                if($company->status != Company::STATUS_ACTIVE) {
488
                    return [
489
                        'success'   => false,
490
                        'data'   => 'ERROR_COMPANY_IS_NOT_ACTIVE'
491
                    ];
492
                }
493
 
494
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
495
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
496
 
497
                //print_r($companyUser); exit;
498
 
499
 
500
                if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
501
                    return [
502
                        'success'   => false,
503
                        'data'   => 'ERROR_UNAUTHORIZED'
504
                    ];
505
                }
506
 
507
            }
508
 
509
            if($groupId) {
510
                $groupMapper = GroupMapper::getInstance($this->adapter);
511
                $group = $groupMapper->fetchOneByUuid($groupId);
512
 
513
                if(!$group) {
514
                    return [
515
                        'success'   => false,
516
                        'data'   => 'ERROR_GROUP_NOT_FOUND'
517
                    ];
518
                }
519
 
520
                if($group->status != Group::STATUS_ACTIVE) {
521
                    return [
522
                        'success'   => false,
523
                        'data'   => 'ERROR_GROUP_IS_NOT_ACTIVE'
524
                    ];
525
                }
526
 
527
                $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
528
                $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
529
                if(!$groupMember || !in_array($groupMember->status, [GroupMember::STATUS_ACCEPTED, GroupMember::STATUS_AUTO_JOIN])) {
530
                    return [
531
                        'success'   => false,
532
                        'data'   => 'ERROR_UNAUTHORIZED'
533
                    ];
534
                }
535
            }
536
 
537
            $feed->company_id   = $company ? $company->id : null;
538
            $feed->group_id     = $group ? $group->id : null;
539
            $feed->user_id      = $currentUser->id;
540
 
541
            if($companyId) {
542
                $feed->type = Feed::TYPE_COMPANY;
543
            } else if ($groupId) {
544
                $feed->type = Feed::TYPE_GROUP;
545
            } else {
546
                $feed->type = Feed::TYPE_UPDATE;
547
            }
548
 
549
            $posted_or_shared   = $dataPost['posted_or_shared'];
550
            if($posted_or_shared != Feed::POSTED && $posted_or_shared != Feed::SHARED) {
551
                return [
552
                    'success'   => false,
553
                    'data'      => 'ERROR_SUPPLY_VALID_SHARING_STATUS'
554
                ];
555
            }
556
            $feed->posted_or_shared = $posted_or_shared;
557
            $feedMapper = FeedMapper::getInstance($this->adapter);
558
 
559
            $shared_with = isset($dataPost['shared_with']) ? $dataPost['shared_with'] : Feed::SHARE_WITH_PUBLIC;
560
            if ($shared_with != Feed::SHARE_WITH_PUBLIC && $shared_with != Feed::SHARE_WITH_CONNECTIONS) {
561
                return [
562
                    'status' => false,
563
                    'error' => 'ERROR_SUPPLY_VALID_SHARING_WITH_TYPE',
564
                ];
565
            }
566
 
567
            $feed->shared_with = $shared_with;
568
            if(Feed::SHARED == $feed->posted_or_shared) {
569
                $shared_feed_id     = empty($dataPost['shared_feed_id']) ? 0 : $dataPost['shared_feed_id'];
570
 
571
 
572
                $sharedFeed = $feedMapper->fetchOne($shared_feed_id);
573
                if(!$sharedFeed) {
574
                    return [
575
                        'status' => false,
576
                        'error' => 'ERROR_POST_SHARE',
577
                    ];
578
 
579
                }
580
 
581
                $feed->shared_feed_id       = $sharedFeed->id;
582
                $feed->shared_company_id    = $sharedFeed->shared_company_id;
583
                $feed->shared_group_id      = $sharedFeed->shared_group_id;
584
                $feed->shared_job_id        = $sharedFeed->shared_job_id;
585
            } else {
586
                $sharedFeed = null;
587
            }
588
 
589
            $feed->status = Feed::STATUS_PUBLISHED;
590
            $feed->total_comments    = 0;
591
            $feed->total_shared     = 0;
592
 
593
 
594
            $files = $this->getRequest()->getFiles()->toArray();
595
            $file_type = '';
596
 
597
            $encoding = $this->params()->fromRoute('encoding');
598
            if($encoding == 'base64') {
599
 
600
 
601
                $fileBase64Name = $this->params()->fromPost('file_base64_name');
602
                $fileBase64Content = $this->params()->fromPost('file_base64_content');
603
 
604
                if($fileBase64Name && $fileBase64Content) {
605
 
606
                    try {
607
                        $fileBase64Content = base64_decode($fileBase64Content);
608
                        if($fileBase64Content) {
609
                            $feed_filename      = $this->normalizeString($fileBase64Name);
610
                            $feed_tmp_filename = 'data' . DIRECTORY_SEPARATOR . 'tmp';
611
                            if(!file_exists($feed_tmp_filename)) {
612
                                mkdir($feed_tmp_filename, 0755, true);
613
                            }
614
 
615
 
616
 
617
                            $feed_tmp_filename = 'data' . DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR . $feed_filename;
618
                            file_put_contents($feed_tmp_filename, $fileBase64Content);
619
 
620
 
621
 
622
                            $mime_type = mime_content_type($feed_tmp_filename);
623
                            //echo '$mime_type = '. $mime_type; exit;
624
 
625
 
626
                            if($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {
627
                                $file_type = Feed::FILE_TYPE_IMAGE;
628
                            } else if($mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {
629
                                $file_type = Feed::FILE_TYPE_VIDEO;
630
                            } else if($mime_type == 'application/pdf') {
631
                                $file_type = Feed::FILE_TYPE_DOCUMENT;
632
                            }
633
 
634
                        }
635
                    } catch(\Exception $e) {
636
 
637
                    }
638
                }
639
 
640
            } else {
641
 
642
                if(isset($files['file']) && empty($files['file']['error'])) {
643
                    $feed_tmp_filename  = $files['file']['tmp_name'];
644
                    $feed_filename      = $this->normalizeString($files['file']['name']);
645
 
646
                    $mime_type = mime_content_type($feed_tmp_filename);
647
 
648
 
649
                    if($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {
650
                        $file_type = Feed::FILE_TYPE_IMAGE;
651
                    } else if($mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {
652
                        $file_type = Feed::FILE_TYPE_VIDEO;
653
                    } else if($mime_type == 'application/pdf') {
654
                        $file_type = Feed::FILE_TYPE_DOCUMENT;
655
                    }
656
                }
657
            }
658
 
659
 
660
 
661
            $result = $feedMapper->insert($feed);
662
            if($result) {
663
 
664
                if($sharedFeed && $sharedFeed->type == Feed::TYPE_UPDATE) {
665
 
666
 
667
                    $userMapper = UserMapper::getInstance($this->adapter);
668
                    $ownerFeed = $userMapper->fetchOne($sharedFeed->user_id);
669
 
670
                    $notification = new Notification();
671
                    $notification->type     = Notification::TYPE_SHARE_MY_FEED;
672
                    $notification->read     = Notification::NO;
673
                    $notification->user_id  = $ownerFeed->id;
674
                    $notification->feed_id = $feed->id;
675
                    $notification->message  = 'LABEL_SHARE_MY_FEED';
676
                    $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $sharedFeed->uuid]);
677
 
678
                    $notificationMapper = NotificationMapper::getInstance($this->adapter);
679
                    $notificationMapper->insert($notification);
680
 
681
                    $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
682
                    $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
683
 
684
                    if($userNotification && $userNotification->share_my_feed)
685
                    {
686
                        $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
687
                        $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_SHARE_MY_FEED);
688
 
689
                        if($emailTemplate) {
690
                            $arrayCont = [
691
                                'firstname'             => $currentUser->first_name,
692
                                'lastname'              => $currentUser->last_name,
693
                                'other_user_firstname'  => $ownerFeed->first_name,
694
                                'other_user_lastname'   => $ownerFeed->last_name,
695
                                'company_name'          => '',
696
                                'group_name'            => '',
697
                                'content'               => '',
698
                                'code'                  => '',
699
                                'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
700
                            ];
701
 
702
                            $email = new QueueEmail($this->adapter);
703
                            $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
704
                        }
705
                    }
706
                }
707
 
708
 
709
                $feed = $feedMapper->fetchOne($feed->id);
710
 
711
 
712
 
713
 
714
 
715
                if( $file_type == Feed::FILE_TYPE_DOCUMENT) {
716
                    try {
717
                        $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
718
                        if(!file_exists($target_path)) {
719
                            mkdir($target_path, 0755);
720
                        }
721
 
722
                        $full_filename = $target_path  . DIRECTORY_SEPARATOR .$feed_filename;
723
 
724
                        if($encoding == 'base64') {
725
                            $resultMoveOrRename = rename($feed_tmp_filename , $full_filename);
726
                        } else {
727
                            $resultMoveOrRename = move_uploaded_file($feed_tmp_filename , $full_filename);
728
                        }
729
 
730
                        if($resultMoveOrRename) {
731
 
732
                            $feed->file_type = $file_type;
733
                            $feed->file_name = basename($feed_filename);
734
                            $feedMapper->update($feed);
735
                        } else {
736
                            error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );
737
                        }
738
                    } catch(\Throwable $e) {
739
                        error_log($e->getTraceAsString());
740
                    }
741
                }
742
                if( $file_type == Feed::FILE_TYPE_IMAGE) {
743
                    try {
744
                        $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
745
                        if(!file_exists($target_path)) {
746
                            mkdir($target_path, 0755);
747
                        }
748
 
749
                        list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);
750
 
751
                        $feed_filename = substr($feed_filename, 0, strrpos($feed_filename, '.'))  . '.png';
752
                        $crop_to_dimensions = false;
753
                        if(Image::uploadImage($feed_tmp_filename, $target_path, $feed_filename, $target_width, $target_height, $crop_to_dimensions )) {
754
                            $feed->file_type = $file_type;
755
                            $feed->file_name = basename($feed_filename);
756
                            $feedMapper->update($feed);
757
                        }
758
                    } catch(\Throwable $e) {
759
                        error_log($e->getTraceAsString());
760
                    }
761
                }
762
                if( $file_type == Feed::FILE_TYPE_VIDEO) {
763
                    try {
764
                        $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
765
                        if(!file_exists($target_path)) {
766
                            mkdir($target_path, 0755);
767
                        }
768
 
769
                        $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;
770
 
771
                        if($encoding == 'base64') {
772
                            $resultMoveOrRename = rename($feed_tmp_filename , $full_filename);
773
                        } else {
774
                            $resultMoveOrRename = move_uploaded_file($feed_tmp_filename , $full_filename);
775
                        }
776
 
777
                        if($resultMoveOrRename) {
778
 
779
                            $size = $this->config['leaderslinked.image_sizes.feed_image_size'];
242 efrain 780
                           // $getFromSecound = 2;
1 www 781
 
782
                            //extracción del cover
783
                            $generateFileName = substr($feed_filename, 0, strrpos($feed_filename, '.'));
784
                            $generateFile =  $target_path  . DIRECTORY_SEPARATOR . $generateFileName .  '.png';
242 efrain 785
                           // $cmd            = "/usr/bin/ffmpeg -i $full_filename -an -ss $getFromSecound -s $size $generateFile";
786
                            $cmd            = "/usr/bin/ffmpeg -i $full_filename -frames:v 1 -s $size $generateFile";
787
 
788
 
1 www 789
                            exec($cmd);
790
 
791
 
792
                            $feed->file_type = $file_type;
793
                            $feed->file_name = basename($feed_filename);
794
                            $feed->file_image_preview = basename($generateFile);
795
                            $feedMapper->update($feed);
796
 
797
                            $videoConvert = new VideoConvert();
798
                            $videoConvert->filename = $full_filename;
799
                            $videoConvert->type = VideoConvert::TYPE_FEED;
800
 
801
                            $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
802
                            $videoConvertMapper->insert($videoConvert);
803
                        } else {
804
                            error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );
805
                        }
806
                    } catch(\Throwable $e) {
807
                        error_log($e->getTraceAsString());
808
                    }
809
                }
810
 
811
 
812
                return [
813
                    'success'   => true,
814
                    'data'   => $this->renderFeed($feed->id)
815
                ];
816
           } else {
817
                return [
818
                    'success'   => false,
819
                    'data'   => $feedMapper->getError()
820
                ];
821
           }
822
        } else {
823
            $messages = [];
824
            $form_messages = (array) $form->getMessages();
825
            foreach($form_messages  as $fieldname => $field_messages)
826
            {
827
                $messages[$fieldname] = array_values($field_messages);
828
            }
829
 
830
            return [
831
                'success'   => false,
832
               'data'   => $messages
833
            ];
834
        }
835
    }
836
 
837
    public function likeAction()
838
    {
839
        $id = $this->params()->fromRoute('id');
840
 
841
        $request = $this->getRequest();
842
        if($request->isPost()) {
843
            $currentUserPlugin = $this->plugin('currentUserPlugin');
844
            $currentUser = $currentUserPlugin->getUser();
845
 
846
            $feedMapper = FeedMapper::getInstance($this->adapter);
847
            $feed = $feedMapper->fetchOneByUuid($id);
848
            if(!$feed) {
849
                $response = [
850
                    'success' => false,
851
                    'data' => 'ERROR_POST_NOT_FOUND'
852
                ];
853
                return new JsonModel($response);
854
            }
855
 
856
            $likeMapper = LikeMapper::getInstance($this->adapter);
857
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
858
 
859
            if($like) {
860
                $response = [
861
                    'success' => false,
862
                    'data' => 'ERROR_DUPLICATE_ACTION'
863
                ];
864
                return new JsonModel($response);
865
            }
866
 
867
            $like = new Like();
868
            $like->user_id = $currentUser->id;
869
            $like->feed_id = $feed->id;
870
 
871
            if($likeMapper->insert($like))
872
            {
873
                if($feed->type == Feed::TYPE_UPDATE) {
874
 
875
 
876
                    $userMapper = UserMapper::getInstance($this->adapter);
877
                    $ownerFeed = $userMapper->fetchOne($feed->user_id);
878
 
879
                    $notification = new Notification();
880
                    $notification->type     = Notification::TYPE_LIKE_MY_FEED;
881
                    $notification->read     = Notification::NO;
882
                    $notification->user_id  = $ownerFeed->id;
883
                    $notification->feed_id = $feed->id;
884
                    $notification->message  = 'LABEL_LIKE_MY_FEED';
885
                    $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $feed->uuid]);
886
 
887
                    $notificationMapper = NotificationMapper::getInstance($this->adapter);
888
                    $notificationMapper->insert($notification);
889
 
890
                    $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
891
                    $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
892
 
893
                    if($userNotification && $userNotification->like_my_feed)
894
                    {
895
                        $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
896
                        $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_LIKE_MY_FEED);
897
 
898
                        if($emailTemplate) {
899
                            $arrayCont = [
900
                                'firstname'             => $currentUser->first_name,
901
                                'lastname'              => $currentUser->last_name,
902
                                'other_user_firstname'  => $ownerFeed->first_name,
903
                                'other_user_lastname'   => $ownerFeed->last_name,
904
                                'company_name'          => '',
905
                                'group_name'            => '',
906
                                'content'               => '',
907
                                'code'                  => '',
908
                                'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
909
                            ];
910
 
911
                            $email = new QueueEmail($this->adapter);
912
                            $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
913
                        }
914
                    }
915
 
916
                }
917
 
918
 
919
 
920
 
921
 
922
 
923
 
924
 
925
                $response = [
926
                    'success' =>true,
927
                ];
928
            } else {
929
                $response = [
930
                    'success' => false,
931
                    'data' => $likeMapper->getError()
932
                ];
933
            }
934
            return new JsonModel($response);
935
 
936
        }
937
 
938
        $response = [
939
            'success' => false,
940
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
941
        ];
942
        return new JsonModel($response);
943
    }
944
 
945
    public function unlikeAction()
946
    {
947
        $id = $this->params()->fromRoute('id');
948
 
949
        $request = $this->getRequest();
950
        if($request->isPost()) {
951
            $currentUserPlugin = $this->plugin('currentUserPlugin');
952
            $currentUser = $currentUserPlugin->getUser();
953
 
954
            $feedMapper = FeedMapper::getInstance($this->adapter);
955
            $feed = $feedMapper->fetchOneByUuid($id);
956
            if(!$feed) {
957
                $response = [
958
                    'success' => false,
959
                    'data' => 'ERROR_POST_NOT_FOUND'
960
                ];
961
                return new JsonModel($response);
962
            }
963
 
964
            $likeMapper = LikeMapper::getInstance($this->adapter);
965
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
966
 
967
            if(!$like) {
968
                $response = [
969
                    'success' => false,
970
                    'data' => 'ERROR_DUPLICATE_ACTION'
971
                ];
972
                return new JsonModel($response);
973
            }
974
 
975
            if($likeMapper->deleteByFeedIdAndUserId($feed->id, $currentUser->id))
976
            {
977
                $response = [
978
                    'success' =>true,
979
                ];
980
            } else {
981
                $response = [
982
                    'success' => false,
983
                    'data' => $likeMapper->getError()
984
                ];
985
            }
986
            return new JsonModel($response);
987
 
988
        }
989
 
990
        $response = [
991
            'success' => false,
992
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
993
        ];
994
        return new JsonModel($response);
995
    }
996
 
997
    public function timelineAction()
998
    {
999
        $currentUserPlugin = $this->plugin('currentUserPlugin');
1000
        $currentUser = $currentUserPlugin->getUser();
1001
 
1002
 
1003
        $type   = $this->params()->fromRoute('type');
1004
        if($type == 'user') {
1005
            $id = $currentUser->id;
1006
        } else {
1007
            $id     = $this->params()->fromRoute('id');
1008
        }
1009
 
1010
 
1011
 
1012
        $request = $this->getRequest();
1013
        if($request->isGet()) {
1014
 
1015
            $page = (int) $this->params()->fromQuery('page');
1016
            if($type == 'user') {
1017
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
1018
                $records = $connectionMapper->fetchAllConnectionsByUser($id);
1019
 
1020
                $connectionIds = [0];
1021
                foreach($records as $record)
1022
                {
1023
                    if($currentUser->id == $record->request_from) {
1024
                        array_push($connectionIds, $record->request_to);
1025
                    } else {
1026
                        array_push($connectionIds, $record->request_from);
1027
                    }
1028
                }
1029
                array_push($connectionIds, 1);
1030
 
1031
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
1032
                $records = $companyFollowerMapper->fetchAllByFollowerId($currentUser->id);
1033
 
1034
                $companyIds = [0];
1035
                foreach($records as $record)
1036
                {
1037
                    if(!in_array($record->company_id, $companyIds)) {
1038
                        array_push($companyIds, $record->company_id);
1039
                    }
1040
                }
1041
 
1042
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1043
                $companyUsers = $companyUserMapper->fetchAllByUserId($currentUser->id);
1044
 
1045
                foreach($companyUsers as $companyUser)
1046
                {
1047
                    if($companyUser->status == CompanyUser::STATUS_ACCEPTED) {
1048
                        if(!in_array($companyUser->company_id, $companyIds)) {
1049
                            array_push($companyIds, $companyUser->company_id);
1050
                        }
1051
                    }
1052
                }
1053
 
1054
 
1055
                $queryMapper = QueryMapper::getInstance($this->adapter);
1056
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
1057
                $select->columns(['id']);
1058
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED)
1059
                    ->AND->NEST
1060
                    ->OR->NEST->equalTo('user_id',$id)->and->equalTo('type', Feed::TYPE_UPDATE)->UNNEST
1061
                    ->OR->NEST->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_PUBLIC)->UNNEST
1062
                    ->OR->NEST->in('user_id', $connectionIds)->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_CONNECTIONS)->UNNEST
1063
                    ->OR->NEST->or->in('company_id', $companyIds)->and->equalTo('type', Feed::TYPE_COMPANY)->UNNEST
1064
                    ->UNNEST;
1065
                $select->order('added_on desc');
1066
 
1067
 
1068
            }
1069
            if($type == 'company') {
1070
                $companyMapper = CompanyMapper::getInstance($this->adapter);
1071
                $company = $companyMapper->fetchOneByUuid($id);
1072
 
1073
                if(!$company || $company->status != Company::STATUS_ACTIVE) {
1074
                    $id = 0;
1075
                } else {
1076
                    $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
1077
                    $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
1078
                    if($companyFollower) {
1079
                        $id = $company->id;
1080
                    } else {
1081
 
1082
                        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1083
                        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
1084
 
1085
                        if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
1086
                            $id = 0;
1087
                        } else {
1088
                            $id = $company->id;
1089
                        }
1090
 
1091
                    }
1092
 
1093
                }
1094
 
1095
 
1096
                $queryMapper = QueryMapper::getInstance($this->adapter);
1097
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
1098
                $select->columns(['id']);
1099
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
1100
                $select->where->equalTo('company_id',$id);
1101
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
1102
                $select->order('added_on desc');
1103
            }
1104
            if($type == 'group') {
1105
                $groupMapper = GroupMapper::getInstance($this->adapter);
1106
                $group = $groupMapper->fetchOneByUuid($id);
1107
                if(!$group || $group->status != Group::STATUS_ACTIVE) {
1108
                    $id = 0;
1109
                } else {
1110
                    $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
1111
                    $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
1112
                    if($groupMember) {
1113
                        $id = $groupMember->status == GroupMember::STATUS_ACCEPTED ? $group->id : 0;
1114
 
1115
                    } else {
1116
                        $id = 0;
1117
                    }
1118
                }
1119
 
1120
                $queryMapper = QueryMapper::getInstance($this->adapter);
1121
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
1122
                $select->columns(['id']);
1123
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
1124
                $select->where->equalTo('group_id',$id);
1125
                $select->where->and->equalTo('type', Feed::TYPE_GROUP);
1126
                $select->order('added_on desc');
1127
            }
1128
 
1129
            $dbSelect = new DbSelect($select, $this->adapter);
1130
            $paginator = new Paginator($dbSelect);
1131
            $paginator->setCurrentPageNumber($page ? $page : 1);
1132
            $paginator->setItemCountPerPage(10);
1133
 
1134
            $items = [];
1135
            $feeds = $paginator->getCurrentItems();
1136
            foreach($feeds as $feed)
1137
            {
1138
                $items[] = $this->renderFeed($feed->id);
1139
            }
1140
 
1141
            $response = [
1142
                'success' => true,
1143
                'data' => [
1144
                    'total' => [
1145
                        'count' => $paginator->getTotalItemCount(),
1146
                        'pages' => $paginator->getPages()->pageCount,
1147
                    ],
1148
                    'current' => [
1149
                        'items'    => $items,
1150
                        'page'     => $paginator->getCurrentPageNumber(),
1151
                        'count'    => $paginator->getCurrentItemCount(),
1152
                    ]
1153
                ]
1154
            ];
1155
 
1156
            return new JsonModel($response);
1157
        }
1158
 
1159
        $response = [
1160
            'success' => false,
1161
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
1162
        ];
1163
 
1164
 
1165
        return new JsonModel($response);
1166
    }
1167
 
1168
    /**
1169
     *
1170
     * @param string $str
1171
     * @return string
1172
     */
1173
    private function normalizeString ($str = '')
1174
    {
1175
        $basename  = substr($str, 0, strrpos($str, '.'));
1176
        $basename  = str_replace('.', '-', $basename);
1177
 
1178
        $extension  = substr($str, strrpos($str, '.'));
1179
 
1180
        $str = $basename . $extension;
1181
 
1182
        $str = strip_tags($str);
1183
        $str = preg_replace('/[\r\n\t ]+/', ' ', $str);
1184
        $str = preg_replace('/[\"\*\/\:\<\>\?\'\|\,]+/', ' ', $str);
1185
        $str = strtolower($str);
1186
        $str = html_entity_decode( $str, ENT_QUOTES, "utf-8" );
1187
        $str = htmlentities($str, ENT_QUOTES, "utf-8");
1188
        $str = preg_replace("/(&)([a-z])([a-z]+;)/i", '$2', $str);
1189
        $str = str_replace(' ', '-', $str);
1190
        $str = rawurlencode($str);
1191
        $str = str_replace('%', '-', $str);
1192
        return trim(strtolower($str));
1193
    }
1194
 
1195
 
1196
 
1197
    /**
1198
     *
1199
     * @param int $feed_id
1200
     * @return array
1201
     */
1202
    private function renderFeed($feed_id)
1203
    {
1204
        $currentUserPlugin = $this->plugin('currentUserPlugin');
1205
        $currentUser = $currentUserPlugin->getUser();
1206
 
1207
        $acl = $this->getEvent()->getViewModel()->getVariable('acl');
1208
 
1209
        $userMapper = UserMapper::getInstance($this->adapter);
1210
        $feedMapper = FeedMapper::getInstance($this->adapter);
1211
        $feed = $feedMapper->fetchOne($feed_id);
1212
 
1213
 
1214
        $likeMapper = LikeMapper::getInstance($this->adapter);
1215
        $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
1216
 
1217
        $params = [
1218
            'id' => $feed->uuid
1219
        ];
1220
        if($feed->company_id) {
1221
            $companyMapper = CompanyMapper::getInstance($this->adapter);
1222
            $company = $companyMapper->fetchOne($feed->company_id);
1223
 
1224
            $params['company_id'] = $company->uuid;
1225
        } else {
1226
            $company = null;
1227
        }
1228
        if($feed->group_id) {
1229
            $groupMapper = GroupMapper::getInstance($this->adapter);
1230
            $group = $groupMapper->fetchOne($feed->group_id);
1231
 
1232
            $params['group_id'] = $group->uuid;
1233
        } else {
1234
            $group = null;
1235
        }
1236
 
1237
        $item = [
1238
            'feed_unique' => uniqid(),
1239
            'feed_uuid' => $feed->uuid,
1240
            'feed_is_liked' => $like ? true : false,
1241
            'feed_like_url' => $this->url()->fromRoute('feed/like',  $params),
1242
            'feed_unlike_url' => $this->url()->fromRoute('feed/unlike',  $params),
1243
            'feed_share_url' => $this->url()->fromRoute('feed/share',  $params),
1244
            'feed_delete_url' =>  '',
1245
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
1246
        ];
1247
 
1248
        if($feed->posted_or_shared == Feed::POSTED) {
1249
 
1250
 
1251
            if($feed->type == Feed::TYPE_COMPANY)
1252
            {
1253
                $companyMapper = CompanyMapper::getInstance($this->adapter);
1254
                $company = $companyMapper->fetchOne($feed->company_id);
1255
                $item['owner_url'] = $this->url()->fromRoute('company/view', ['id' => $company->uuid]);
1256
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]);
1257
                $item['owner_name'] = $company->name;
1258
                /*
1259
 
1260
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1261
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
1262
 
1263
 
1264
                if( $companyUser && $acl->isAllowed( $currentUser->usertype_id, 'my-company/feed' ) ) {
1265
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1266
                }
1267
                */
1268
 
1269
 
1270
            } else if($feed->type == Feed::TYPE_GROUP)
1271
            {
1272
                $groupMapper = GroupMapper::getInstance($this->adapter);
1273
                $group = $groupMapper->fetchOne($feed->group_id);
1274
                $item['owner_url'] = '';
1275
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $group->uuid, 'type' => 'group', 'filename' => $group->image]);
1276
                $item['owner_name'] = $group->name;
1277
 
1278
                if($group->user_id == $currentUser->id) {
1279
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1280
                }
1281
            } else {
1282
                $userMapper = UserMapper::getInstance($this->adapter);
1283
                $user = $userMapper->fetchOne($feed->user_id);
1284
 
1285
                $item['owner_url'] = $this->url()->fromRoute('profile/view', ['id' => $user->uuid]);
1286
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
1287
                $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
1288
 
1289
                if($feed->user_id == $currentUser->id) {
1290
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1291
                }
1292
 
1293
            }
1294
        } else {
1295
            if($feed->user_id == $currentUser->id) {
1296
                $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1297
            }
1298
        }
1299
 
1300
        $userMapper = UserMapper::getInstance($this->adapter);
1301
        $user = $userMapper->fetchOne($feed->user_id);
1302
 
1303
        if($feed->posted_or_shared == Feed::SHARED) {
1304
            $item['owner_url'] = $this->url()->fromRoute('profile/view', ['id' => $user->uuid]);
1305
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
1306
            $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
1307
        }
1308
 
1309
        $item['owner_description'] = $feed->description;
1310
 
1311
        $item['owner_shared'] = $feed->total_shared;
1312
        $item['owner_comments'] = $feed->total_comments;
1313
 
1314
 
1315
        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $feed->added_on);
1316
        $item['owner_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
1317
 
1318
        if($feed->file_type == Feed::FILE_TYPE_IMAGE) {
1319
            $item['owner_file_image'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1320
 
1321
        }
1322
        if($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {
1323
            $item['owner_file_document'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1324
        }
1325
        if($feed->file_type == Feed::FILE_TYPE_VIDEO) {
1326
            $item['owner_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_image_preview]);
1327
            $item['owner_file_video'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1328
        }
1329
 
1330
        if($feed->posted_or_shared == Feed::SHARED) {
1331
 
1332
 
1333
            $sharedFeed = $feedMapper->fetchOne($feed->shared_feed_id);
1334
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $sharedFeed->added_on);
1335
 
1336
 
1337
            $item['shared_description'] = $sharedFeed->description;
1338
            $item['shared_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
1339
 
1340
            if($sharedFeed->file_type == Feed::FILE_TYPE_IMAGE) {
1341
                $item['shared_file_image'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1342
 
1343
            }
1344
            if($sharedFeed->file_type == Feed::FILE_TYPE_DOCUMENT) {
1345
                $item['shared_file_document'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1346
            }
1347
            if($sharedFeed->file_type == Feed::FILE_TYPE_VIDEO) {
1348
                $item['shared_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_image_preview]);
1349
                $item['shared_file_video'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1350
            }
1351
 
1352
            $item['shared_content_type'] = $sharedFeed->file_type ? $sharedFeed->file_type : '';
1353
 
1354
            if($feed->company_id)
1355
            {
1356
 
1357
                $companyMapper = CompanyMapper::getInstance($this->adapter);
1358
                $sharedCompany = $companyMapper->fetchOne($feed->company_id);
1359
                $item['shared_url'] = $this->url()->fromRoute('company/view', ['id' => $sharedCompany->uuid]);
1360
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedCompany->uuid, 'type' => 'company', 'filename' => $sharedCompany->image]);
1361
                $item['shared_name'] = $sharedCompany->name;
1362
            } else if($feed->group_id)
1363
            {
1364
                $groupMapper = GroupMapper::getInstance($this->adapter);
1365
                $sharedGroup = $groupMapper->fetchOne($feed->group_id);
1366
                $item['shared_url'] = '';
1367
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedGroup->uuid, 'type' => 'group', 'filename' =>  $sharedGroup->image]);
1368
                $item['shared_name'] = $sharedGroup->name;
1369
            } else {
1370
 
1371
                $sharedUser = $userMapper->fetchOne($sharedFeed->user_id);
1372
                $item['shared_url'] = $this->url()->fromRoute('profile/view', ['id' => $sharedUser->uuid]);
1373
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedUser->uuid, 'type' => 'user', 'filename' => $sharedUser->image]);
1374
                $item['shared_name'] = $sharedUser->first_name . ' ' . $sharedUser->last_name;
1375
            }
1376
 
1377
        }
1378
 
1379
        $commentMapper = CommentMapper::getInstance($this->adapter);
1380
        $records = $commentMapper->fetchAllPublishedByFeedId($feed->id);
1381
 
1382
        $comments = [];
1383
        foreach($records as $record)
1384
        {
1385
            $user = $userMapper->fetchOne($record->user_id);
1386
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
1387
 
1388
            if($record->user_id == $currentUser->id) {
1389
                $link_delete = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid]);
1390
            } else {
1391
                $link_delete = '';
1392
            }
1393
 
1394
            array_push($comments, [
1395
                'unique' => uniqid(),
1396
                'user_url' => $this->url()->fromRoute('profile/view', ['id' => $user->uuid]),
1397
                'user_name' => $user->first_name . ' ' . $user->last_name,
1398
                'user_image' => $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]),
1399
                'time_elapsed' => Functions::timeElapsedString($dt->getTimestamp()),
1400
                'comment' => $record->comment,
1401
                'link_delete' => $link_delete
1402
            ]);
1403
        }
1404
        $item['comment_add_url'] = $this->url()->fromRoute('feed/comment', ['id' => $feed->uuid]);
1405
        $item['comments'] = $comments;
1406
 
1407
        return $item;
1408
    }
1409
 
1410
    /**
1411
     *
1412
     * @param int $comment_id
1413
     * @return array
1414
     */
1415
    private function renderComment($comment_id)
1416
    {
1417
        $item = [];
1418
 
1419
        $commentMapper = CommentMapper::getInstance($this->adapter);
1420
        $record = $commentMapper->fetchOne($comment_id);
1421
 
1422
        $feedMapper = FeedMapper::getInstance($this->adapter);
1423
        $feed = $feedMapper->fetchOne($record->feed_id);
1424
 
1425
        if($record) {
1426
            $userMapper = UserMapper::getInstance($this->adapter);
1427
 
1428
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
1429
 
1430
 
1431
            $user = $userMapper->fetchOne($record->user_id);
1432
 
1433
            $item['unique'] = uniqid();
1434
            $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
1435
            $item['user_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
1436
            $item['user_name'] = $user->first_name . ' ' . $user->last_name;
1437
            $item['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
1438
            $item['comment'] = $record->comment;
1439
            $item['link_delete'] = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
1440
        }
1441
        return $item;
1442
    }
1443
 
1444
    /**
1445
     *
1446
     * @param string $path
1447
     * @return boolean
1448
     */
1449
    private function deletePath($path)
1450
    {
1451
        try {
1452
            if (is_dir($path)){
1453
                if ($dh = opendir($path)) {
1454
                    while (($file = readdir($dh)) !== false)
1455
                    {
1456
                        if($file == '.' || $file == '..') {
1457
                            continue;
1458
                        }
1459
                        unlink($path . DIRECTORY_SEPARATOR . $file);
1460
                    }
1461
                    closedir($dh);
1462
                }
1463
 
1464
                rmdir($path);
1465
            }
1466
            return true;
1467
        }
1468
        catch (\Throwable $e)
1469
        {
1470
            error_log($e->getTraceAsString());
1471
            return false;
1472
        }
1473
    }
1474
 
1475
 
1476
    /**
1477
     *
1478
     * @param Feed $feed
1479
     * @return array
1480
     */
1481
    private function deleteFeed($feed)
1482
    {
1483
        $feedMapper = FeedMapper::getInstance($this->adapter);
1484
        $feed->status = Feed::STATUS_DELETED;
1485
        if($feedMapper->update($feed)) {
1486
            $response = [
1487
                'success' => true,
1488
                'data' => 'LABEL_FEED_WAS_DELETED'
1489
            ];
1490
 
1491
        } else {
1492
            $response = [
1493
                'success' => false,
1494
                'data' => $feedMapper->getError()
1495
            ];
1496
        }
1497
 
1498
 
1499
        /*$commentMapper = CommentMapper::getInstance($this->adapter);
1500
        if($commentMapper->deleteAllByFeedId($feed->id)) {
1501
            if($feedMapper->delete($feed->id)) {
1502
                $target_path = $this->config['leaderslinked.fullpath.feed'] . DIRECTORY_SEPARATOR . $feed->id;
1503
                if(file_exists($target_path)) {
1504
                    $this->deletePath($target_path);
1505
                }
1506
 
1507
                $response = [
1508
                    'success' => true,
1509
                    'data' => 'LABEL_FEED_WAS_DELETED'
1510
                ];
1511
 
1512
            } else {
1513
                $response = [
1514
                    'success' => false,
1515
                    'data' => $feedMapper->getError()
1516
                ];
1517
            }
1518
        } else {
1519
            $response = [
1520
                'success' => false,
1521
                'data' => $commentMapper->getError()
1522
            ];
1523
 
1524
        }*/
1525
 
1526
        return $response;
1527
    }
1528
 
1529
 
1530
}