Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 413 | Rev 415 | 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');
427
            $response = $this->postOrShareFeed($dataPost);
428
 
429
 
430
            return new JsonModel($response);
431
 
432
        } else {
433
            $response = [
434
                'success' => false,
435
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
436
            ];
437
        }
438
 
439
        return new JsonModel($response);
440
    }
441
 
442
    public function postOrShareFeed($dataPost)
443
    {
444
        $currentUserPlugin = $this->plugin('currentUserPlugin');
445
        $currentUser = $currentUserPlugin->getUser();
446
 
447
        $companyId  = empty($dataPost['company_id']) ? '' : $dataPost['company_id'];
448
        $groupId    = empty($dataPost['group_id']) ? '' : $dataPost['group_id'];
449
 
450
 
451
        if($groupId || $companyId) {
452
            $form = new  CreateGroupCompanyForm($this->adapter);
453
        } else {
454
            $form = new  CreateForm($this->adapter);
455
        }
456
        $form->setData($dataPost);
457
        if($form->isValid()) {
458
 
412 geraldo 459
 
460
 
1 www 461
 
462
            $hydrator = new ObjectPropertyHydrator();
463
            $feed = new Feed();
464
            $hydrator->hydrate($dataPost, $feed);
465
 
466
            $company = null;
467
            $group = null;
468
 
469
            if($companyId) {
470
                $companyMapper = CompanyMapper::getInstance($this->adapter);
471
                $company = $companyMapper->fetchOneByUuid($companyId);
472
 
473
 
474
                if(!$company) {
475
                    return [
476
                        'success'   => false,
477
                        'data'   => 'ERROR_COMPANY_NOT_FOUND'
478
                    ];
479
                }
480
 
481
                if($company->status != Company::STATUS_ACTIVE) {
482
                    return [
483
                        'success'   => false,
484
                        'data'   => 'ERROR_COMPANY_IS_NOT_ACTIVE'
485
                    ];
486
                }
487
 
488
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
489
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
490
 
491
                //print_r($companyUser); exit;
492
 
493
 
494
                if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
495
                    return [
496
                        'success'   => false,
497
                        'data'   => 'ERROR_UNAUTHORIZED'
498
                    ];
499
                }
500
 
501
            }
502
 
503
            if($groupId) {
504
                $groupMapper = GroupMapper::getInstance($this->adapter);
505
                $group = $groupMapper->fetchOneByUuid($groupId);
506
 
507
                if(!$group) {
508
                    return [
509
                        'success'   => false,
510
                        'data'   => 'ERROR_GROUP_NOT_FOUND'
511
                    ];
512
                }
513
 
514
                if($group->status != Group::STATUS_ACTIVE) {
515
                    return [
516
                        'success'   => false,
517
                        'data'   => 'ERROR_GROUP_IS_NOT_ACTIVE'
518
                    ];
519
                }
520
 
521
                $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
522
                $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
523
                if(!$groupMember || !in_array($groupMember->status, [GroupMember::STATUS_ACCEPTED, GroupMember::STATUS_AUTO_JOIN])) {
524
                    return [
525
                        'success'   => false,
526
                        'data'   => 'ERROR_UNAUTHORIZED'
527
                    ];
528
                }
529
            }
530
 
531
            $feed->company_id   = $company ? $company->id : null;
532
            $feed->group_id     = $group ? $group->id : null;
533
            $feed->user_id      = $currentUser->id;
413 geraldo 534
 
535
            if($companyId) {
536
                $feed->type = Feed::TYPE_COMPANY;
537
            } else if ($groupId) {
538
                $feed->type = Feed::TYPE_GROUP;
539
            } else {
540
                $feed->type = Feed::TYPE_UPDATE;
541
            }
542
 
543
            $posted_or_shared   = $dataPost['posted_or_shared'];
544
            if($posted_or_shared != Feed::POSTED && $posted_or_shared != Feed::SHARED) {
545
                return [
546
                    'success'   => false,
547
                    'data'      => 'ERROR_SUPPLY_VALID_SHARING_STATUS'
548
                ];
549
            }
550
            $feed->posted_or_shared = $posted_or_shared;
551
            $feedMapper = FeedMapper::getInstance($this->adapter);
414 geraldo 552
 
553
            $shared_with = isset($dataPost['shared_with']) ? $dataPost['shared_with'] : Feed::SHARE_WITH_PUBLIC;
554
            if ($shared_with != Feed::SHARE_WITH_PUBLIC && $shared_with != Feed::SHARE_WITH_CONNECTIONS) {
555
                return [
556
                    'status' => false,
557
                    'error' => 'ERROR_SUPPLY_VALID_SHARING_WITH_TYPE',
558
                ];
559
            }
560
 
561
            $feed->shared_with = $shared_with;
562
            if(Feed::SHARED == $feed->posted_or_shared) {
563
                $shared_feed_id     = empty($dataPost['shared_feed_id']) ? 0 : $dataPost['shared_feed_id'];
564
 
565
 
566
                $sharedFeed = $feedMapper->fetchOne($shared_feed_id);
567
                if(!$sharedFeed) {
568
                    return [
569
                        'status' => false,
570
                        'error' => 'ERROR_POST_SHARE',
571
                    ];
572
 
573
                }
574
 
575
                $feed->shared_feed_id       = $sharedFeed->id;
576
                $feed->shared_company_id    = $sharedFeed->shared_company_id;
577
                $feed->shared_group_id      = $sharedFeed->shared_group_id;
578
                $feed->shared_job_id        = $sharedFeed->shared_job_id;
579
            } else {
580
                $sharedFeed = null;
581
            }
582
 
583
            $feed->status = Feed::STATUS_PUBLISHED;
584
            $feed->total_comments    = 0;
585
            $feed->total_shared     = 0;
586
 
1 www 587
 
414 geraldo 588
            $files = $this->getRequest()->getFiles()->toArray();
589
            $file_type = '';
590
 
1 www 591
            return [
592
                'success'   => false,
414 geraldo 593
               'datos'   => $feed
1 www 594
            ];
595
        }
596
    }
597
 
598
    public function likeAction()
599
    {
600
        $id = $this->params()->fromRoute('id');
601
 
602
        $request = $this->getRequest();
603
        if($request->isPost()) {
604
            $currentUserPlugin = $this->plugin('currentUserPlugin');
605
            $currentUser = $currentUserPlugin->getUser();
606
 
607
            $feedMapper = FeedMapper::getInstance($this->adapter);
608
            $feed = $feedMapper->fetchOneByUuid($id);
609
            if(!$feed) {
610
                $response = [
611
                    'success' => false,
612
                    'data' => 'ERROR_POST_NOT_FOUND'
613
                ];
614
                return new JsonModel($response);
615
            }
616
 
617
            $likeMapper = LikeMapper::getInstance($this->adapter);
618
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
619
 
620
            if($like) {
621
                $response = [
622
                    'success' => false,
623
                    'data' => 'ERROR_DUPLICATE_ACTION'
624
                ];
625
                return new JsonModel($response);
626
            }
627
 
628
            $like = new Like();
629
            $like->user_id = $currentUser->id;
630
            $like->feed_id = $feed->id;
631
 
632
            if($likeMapper->insert($like))
633
            {
634
                if($feed->type == Feed::TYPE_UPDATE) {
635
 
636
 
637
                    $userMapper = UserMapper::getInstance($this->adapter);
638
                    $ownerFeed = $userMapper->fetchOne($feed->user_id);
639
 
640
                    $notification = new Notification();
641
                    $notification->type     = Notification::TYPE_LIKE_MY_FEED;
642
                    $notification->read     = Notification::NO;
643
                    $notification->user_id  = $ownerFeed->id;
644
                    $notification->feed_id = $feed->id;
645
                    $notification->message  = 'LABEL_LIKE_MY_FEED';
646
                    $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $feed->uuid]);
647
 
648
                    $notificationMapper = NotificationMapper::getInstance($this->adapter);
649
                    $notificationMapper->insert($notification);
650
 
651
                    $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
652
                    $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
653
 
654
                    if($userNotification && $userNotification->like_my_feed)
655
                    {
656
                        $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
657
                        $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_LIKE_MY_FEED);
658
 
659
                        if($emailTemplate) {
660
                            $arrayCont = [
661
                                'firstname'             => $currentUser->first_name,
662
                                'lastname'              => $currentUser->last_name,
663
                                'other_user_firstname'  => $ownerFeed->first_name,
664
                                'other_user_lastname'   => $ownerFeed->last_name,
665
                                'company_name'          => '',
666
                                'group_name'            => '',
667
                                'content'               => '',
668
                                'code'                  => '',
669
                                'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
670
                            ];
671
 
672
                            $email = new QueueEmail($this->adapter);
673
                            $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
674
                        }
675
                    }
676
 
677
                }
678
 
679
 
680
 
681
 
682
 
683
 
684
 
685
 
686
                $response = [
687
                    'success' =>true,
688
                ];
689
            } else {
690
                $response = [
691
                    'success' => false,
692
                    'data' => $likeMapper->getError()
693
                ];
694
            }
695
            return new JsonModel($response);
696
 
697
        }
698
 
699
        $response = [
700
            'success' => false,
701
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
702
        ];
703
        return new JsonModel($response);
704
    }
705
 
706
    public function unlikeAction()
707
    {
708
        $id = $this->params()->fromRoute('id');
709
 
710
        $request = $this->getRequest();
711
        if($request->isPost()) {
712
            $currentUserPlugin = $this->plugin('currentUserPlugin');
713
            $currentUser = $currentUserPlugin->getUser();
714
 
715
            $feedMapper = FeedMapper::getInstance($this->adapter);
716
            $feed = $feedMapper->fetchOneByUuid($id);
717
            if(!$feed) {
718
                $response = [
719
                    'success' => false,
720
                    'data' => 'ERROR_POST_NOT_FOUND'
721
                ];
722
                return new JsonModel($response);
723
            }
724
 
725
            $likeMapper = LikeMapper::getInstance($this->adapter);
726
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
727
 
728
            if(!$like) {
729
                $response = [
730
                    'success' => false,
731
                    'data' => 'ERROR_DUPLICATE_ACTION'
732
                ];
733
                return new JsonModel($response);
734
            }
735
 
736
            if($likeMapper->deleteByFeedIdAndUserId($feed->id, $currentUser->id))
737
            {
738
                $response = [
739
                    'success' =>true,
740
                ];
741
            } else {
742
                $response = [
743
                    'success' => false,
744
                    'data' => $likeMapper->getError()
745
                ];
746
            }
747
            return new JsonModel($response);
748
 
749
        }
750
 
751
        $response = [
752
            'success' => false,
753
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
754
        ];
755
        return new JsonModel($response);
756
    }
757
 
758
    public function timelineAction()
759
    {
760
        $currentUserPlugin = $this->plugin('currentUserPlugin');
761
        $currentUser = $currentUserPlugin->getUser();
762
 
763
 
764
        $type   = $this->params()->fromRoute('type');
765
        if($type == 'user') {
766
            $id = $currentUser->id;
767
        } else {
768
            $id     = $this->params()->fromRoute('id');
769
        }
770
 
771
 
772
 
773
        $request = $this->getRequest();
774
        if($request->isGet()) {
775
 
776
            $page = (int) $this->params()->fromQuery('page');
777
            if($type == 'user') {
778
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
779
                $records = $connectionMapper->fetchAllConnectionsByUser($id);
780
 
781
                $connectionIds = [0];
782
                foreach($records as $record)
783
                {
784
                    if($currentUser->id == $record->request_from) {
785
                        array_push($connectionIds, $record->request_to);
786
                    } else {
787
                        array_push($connectionIds, $record->request_from);
788
                    }
789
                }
790
                array_push($connectionIds, 1);
791
 
792
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
793
                $records = $companyFollowerMapper->fetchAllByFollowerId($currentUser->id);
794
 
795
                $companyIds = [0];
796
                foreach($records as $record)
797
                {
798
                    if(!in_array($record->company_id, $companyIds)) {
799
                        array_push($companyIds, $record->company_id);
800
                    }
801
                }
802
 
803
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
804
                $companyUsers = $companyUserMapper->fetchAllByUserId($currentUser->id);
805
 
806
                foreach($companyUsers as $companyUser)
807
                {
808
                    if($companyUser->status == CompanyUser::STATUS_ACCEPTED) {
809
                        if(!in_array($companyUser->company_id, $companyIds)) {
810
                            array_push($companyIds, $companyUser->company_id);
811
                        }
812
                    }
813
                }
814
 
815
 
816
                $queryMapper = QueryMapper::getInstance($this->adapter);
817
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
818
                $select->columns(['id']);
819
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED)
820
                    ->AND->NEST
821
                    ->OR->NEST->equalTo('user_id',$id)->and->equalTo('type', Feed::TYPE_UPDATE)->UNNEST
822
                    ->OR->NEST->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_PUBLIC)->UNNEST
823
                    ->OR->NEST->in('user_id', $connectionIds)->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_CONNECTIONS)->UNNEST
824
                    ->OR->NEST->or->in('company_id', $companyIds)->and->equalTo('type', Feed::TYPE_COMPANY)->UNNEST
825
                    ->UNNEST;
826
                $select->order('added_on desc');
827
 
828
 
829
            }
830
            if($type == 'company') {
831
                $companyMapper = CompanyMapper::getInstance($this->adapter);
832
                $company = $companyMapper->fetchOneByUuid($id);
833
 
834
                if(!$company || $company->status != Company::STATUS_ACTIVE) {
835
                    $id = 0;
836
                } else {
837
                    $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
838
                    $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
839
                    if($companyFollower) {
840
                        $id = $company->id;
841
                    } else {
842
 
843
                        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
844
                        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
845
 
846
                        if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
847
                            $id = 0;
848
                        } else {
849
                            $id = $company->id;
850
                        }
851
 
852
                    }
853
 
854
                }
855
 
856
 
857
                $queryMapper = QueryMapper::getInstance($this->adapter);
858
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
859
                $select->columns(['id']);
860
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
861
                $select->where->equalTo('company_id',$id);
862
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
863
                $select->order('added_on desc');
864
            }
865
            if($type == 'group') {
866
                $groupMapper = GroupMapper::getInstance($this->adapter);
867
                $group = $groupMapper->fetchOneByUuid($id);
868
                if(!$group || $group->status != Group::STATUS_ACTIVE) {
869
                    $id = 0;
870
                } else {
871
                    $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
872
                    $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
873
                    if($groupMember) {
874
                        $id = $groupMember->status == GroupMember::STATUS_ACCEPTED ? $group->id : 0;
875
 
876
                    } else {
877
                        $id = 0;
878
                    }
879
                }
880
 
881
                $queryMapper = QueryMapper::getInstance($this->adapter);
882
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
883
                $select->columns(['id']);
884
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
885
                $select->where->equalTo('group_id',$id);
886
                $select->where->and->equalTo('type', Feed::TYPE_GROUP);
887
                $select->order('added_on desc');
888
            }
889
 
890
            $dbSelect = new DbSelect($select, $this->adapter);
891
            $paginator = new Paginator($dbSelect);
892
            $paginator->setCurrentPageNumber($page ? $page : 1);
893
            $paginator->setItemCountPerPage(10);
894
 
895
            $items = [];
896
            $feeds = $paginator->getCurrentItems();
897
            foreach($feeds as $feed)
898
            {
899
                $items[] = $this->renderFeed($feed->id);
900
            }
901
 
902
            $response = [
903
                'success' => true,
904
                'data' => [
905
                    'total' => [
906
                        'count' => $paginator->getTotalItemCount(),
907
                        'pages' => $paginator->getPages()->pageCount,
908
                    ],
909
                    'current' => [
910
                        'items'    => $items,
911
                        'page'     => $paginator->getCurrentPageNumber(),
912
                        'count'    => $paginator->getCurrentItemCount(),
913
                    ]
914
                ]
915
            ];
916
 
917
            return new JsonModel($response);
918
        }
919
 
920
        $response = [
921
            'success' => false,
922
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
923
        ];
924
 
925
 
926
        return new JsonModel($response);
927
    }
928
 
929
    /**
930
     *
931
     * @param string $str
932
     * @return string
933
     */
934
    private function normalizeString ($str = '')
935
    {
936
        $basename  = substr($str, 0, strrpos($str, '.'));
937
        $basename  = str_replace('.', '-', $basename);
938
 
939
        $extension  = substr($str, strrpos($str, '.'));
940
 
941
        $str = $basename . $extension;
942
 
943
        $str = strip_tags($str);
944
        $str = preg_replace('/[\r\n\t ]+/', ' ', $str);
945
        $str = preg_replace('/[\"\*\/\:\<\>\?\'\|\,]+/', ' ', $str);
946
        $str = strtolower($str);
947
        $str = html_entity_decode( $str, ENT_QUOTES, "utf-8" );
948
        $str = htmlentities($str, ENT_QUOTES, "utf-8");
949
        $str = preg_replace("/(&)([a-z])([a-z]+;)/i", '$2', $str);
950
        $str = str_replace(' ', '-', $str);
951
        $str = rawurlencode($str);
952
        $str = str_replace('%', '-', $str);
953
        return trim(strtolower($str));
954
    }
955
 
956
 
957
 
958
    /**
959
     *
960
     * @param int $feed_id
961
     * @return array
962
     */
963
    private function renderFeed($feed_id)
964
    {
965
        $currentUserPlugin = $this->plugin('currentUserPlugin');
966
        $currentUser = $currentUserPlugin->getUser();
967
 
968
        $acl = $this->getEvent()->getViewModel()->getVariable('acl');
969
 
970
        $userMapper = UserMapper::getInstance($this->adapter);
971
        $feedMapper = FeedMapper::getInstance($this->adapter);
972
        $feed = $feedMapper->fetchOne($feed_id);
973
 
974
 
975
        $likeMapper = LikeMapper::getInstance($this->adapter);
976
        $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
977
 
978
        $params = [
979
            'id' => $feed->uuid
980
        ];
981
        if($feed->company_id) {
982
            $companyMapper = CompanyMapper::getInstance($this->adapter);
983
            $company = $companyMapper->fetchOne($feed->company_id);
984
 
985
            $params['company_id'] = $company->uuid;
986
        } else {
987
            $company = null;
988
        }
989
        if($feed->group_id) {
990
            $groupMapper = GroupMapper::getInstance($this->adapter);
991
            $group = $groupMapper->fetchOne($feed->group_id);
992
 
993
            $params['group_id'] = $group->uuid;
994
        } else {
995
            $group = null;
996
        }
997
 
998
        $item = [
999
            'feed_unique' => uniqid(),
1000
            'feed_uuid' => $feed->uuid,
1001
            'feed_is_liked' => $like ? true : false,
1002
            'feed_like_url' => $this->url()->fromRoute('feed/like',  $params),
1003
            'feed_unlike_url' => $this->url()->fromRoute('feed/unlike',  $params),
1004
            'feed_share_url' => $this->url()->fromRoute('feed/share',  $params),
1005
            'feed_delete_url' =>  '',
1006
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
1007
        ];
1008
 
1009
        if($feed->posted_or_shared == Feed::POSTED) {
1010
 
1011
 
1012
            if($feed->type == Feed::TYPE_COMPANY)
1013
            {
1014
                $companyMapper = CompanyMapper::getInstance($this->adapter);
1015
                $company = $companyMapper->fetchOne($feed->company_id);
1016
                $item['owner_url'] = $this->url()->fromRoute('company/view', ['id' => $company->uuid]);
1017
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]);
1018
                $item['owner_name'] = $company->name;
1019
                /*
1020
 
1021
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
1022
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
1023
 
1024
 
1025
                if( $companyUser && $acl->isAllowed( $currentUser->usertype_id, 'my-company/feed' ) ) {
1026
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1027
                }
1028
                */
1029
 
1030
 
1031
            } else if($feed->type == Feed::TYPE_GROUP)
1032
            {
1033
                $groupMapper = GroupMapper::getInstance($this->adapter);
1034
                $group = $groupMapper->fetchOne($feed->group_id);
1035
                $item['owner_url'] = '';
1036
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $group->uuid, 'type' => 'group', 'filename' => $group->image]);
1037
                $item['owner_name'] = $group->name;
1038
 
1039
                if($group->user_id == $currentUser->id) {
1040
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1041
                }
1042
            } else {
1043
                $userMapper = UserMapper::getInstance($this->adapter);
1044
                $user = $userMapper->fetchOne($feed->user_id);
1045
 
1046
                $item['owner_url'] = $this->url()->fromRoute('profile/view', ['id' => $user->uuid]);
1047
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
1048
                $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
1049
 
1050
                if($feed->user_id == $currentUser->id) {
1051
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1052
                }
1053
 
1054
            }
1055
        } else {
1056
            if($feed->user_id == $currentUser->id) {
1057
                $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
1058
            }
1059
        }
1060
 
1061
        $userMapper = UserMapper::getInstance($this->adapter);
1062
        $user = $userMapper->fetchOne($feed->user_id);
1063
 
1064
        if($feed->posted_or_shared == Feed::SHARED) {
1065
            $item['owner_url'] = $this->url()->fromRoute('profile/view', ['id' => $user->uuid]);
1066
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
1067
            $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
1068
        }
1069
 
1070
        $item['owner_description'] = $feed->description;
1071
 
1072
        $item['owner_shared'] = $feed->total_shared;
1073
        $item['owner_comments'] = $feed->total_comments;
1074
 
1075
 
1076
        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $feed->added_on);
1077
        $item['owner_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
1078
 
1079
        if($feed->file_type == Feed::FILE_TYPE_IMAGE) {
1080
            $item['owner_file_image'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1081
 
1082
        }
1083
        if($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {
1084
            $item['owner_file_document'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1085
        }
1086
        if($feed->file_type == Feed::FILE_TYPE_VIDEO) {
1087
            $item['owner_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_image_preview]);
1088
            $item['owner_file_video'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
1089
        }
1090
 
1091
        if($feed->posted_or_shared == Feed::SHARED) {
1092
 
1093
 
1094
            $sharedFeed = $feedMapper->fetchOne($feed->shared_feed_id);
1095
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $sharedFeed->added_on);
1096
 
1097
 
1098
            $item['shared_description'] = $sharedFeed->description;
1099
            $item['shared_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
1100
 
1101
            if($sharedFeed->file_type == Feed::FILE_TYPE_IMAGE) {
1102
                $item['shared_file_image'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1103
 
1104
            }
1105
            if($sharedFeed->file_type == Feed::FILE_TYPE_DOCUMENT) {
1106
                $item['shared_file_document'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1107
            }
1108
            if($sharedFeed->file_type == Feed::FILE_TYPE_VIDEO) {
1109
                $item['shared_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_image_preview]);
1110
                $item['shared_file_video'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
1111
            }
1112
 
1113
            $item['shared_content_type'] = $sharedFeed->file_type ? $sharedFeed->file_type : '';
1114
 
1115
            if($feed->company_id)
1116
            {
1117
 
1118
                $companyMapper = CompanyMapper::getInstance($this->adapter);
1119
                $sharedCompany = $companyMapper->fetchOne($feed->company_id);
1120
                $item['shared_url'] = $this->url()->fromRoute('company/view', ['id' => $sharedCompany->uuid]);
1121
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedCompany->uuid, 'type' => 'company', 'filename' => $sharedCompany->image]);
1122
                $item['shared_name'] = $sharedCompany->name;
1123
            } else if($feed->group_id)
1124
            {
1125
                $groupMapper = GroupMapper::getInstance($this->adapter);
1126
                $sharedGroup = $groupMapper->fetchOne($feed->group_id);
1127
                $item['shared_url'] = '';
1128
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedGroup->uuid, 'type' => 'group', 'filename' =>  $sharedGroup->image]);
1129
                $item['shared_name'] = $sharedGroup->name;
1130
            } else {
1131
 
1132
                $sharedUser = $userMapper->fetchOne($sharedFeed->user_id);
1133
                $item['shared_url'] = $this->url()->fromRoute('profile/view', ['id' => $sharedUser->uuid]);
1134
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedUser->uuid, 'type' => 'user', 'filename' => $sharedUser->image]);
1135
                $item['shared_name'] = $sharedUser->first_name . ' ' . $sharedUser->last_name;
1136
            }
1137
 
1138
        }
1139
 
1140
        $commentMapper = CommentMapper::getInstance($this->adapter);
1141
        $records = $commentMapper->fetchAllPublishedByFeedId($feed->id);
1142
 
1143
        $comments = [];
1144
        foreach($records as $record)
1145
        {
1146
            $user = $userMapper->fetchOne($record->user_id);
1147
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
1148
 
1149
            if($record->user_id == $currentUser->id) {
1150
                $link_delete = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid]);
1151
            } else {
1152
                $link_delete = '';
1153
            }
1154
 
1155
            array_push($comments, [
1156
                'unique' => uniqid(),
1157
                'user_url' => $this->url()->fromRoute('profile/view', ['id' => $user->uuid]),
1158
                'user_name' => $user->first_name . ' ' . $user->last_name,
1159
                'user_image' => $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]),
1160
                'time_elapsed' => Functions::timeElapsedString($dt->getTimestamp()),
1161
                'comment' => $record->comment,
1162
                'link_delete' => $link_delete
1163
            ]);
1164
        }
1165
        $item['comment_add_url'] = $this->url()->fromRoute('feed/comment', ['id' => $feed->uuid]);
1166
        $item['comments'] = $comments;
1167
 
1168
        return $item;
1169
    }
1170
 
1171
    /**
1172
     *
1173
     * @param int $comment_id
1174
     * @return array
1175
     */
1176
    private function renderComment($comment_id)
1177
    {
1178
        $item = [];
1179
 
1180
        $commentMapper = CommentMapper::getInstance($this->adapter);
1181
        $record = $commentMapper->fetchOne($comment_id);
1182
 
1183
        $feedMapper = FeedMapper::getInstance($this->adapter);
1184
        $feed = $feedMapper->fetchOne($record->feed_id);
1185
 
1186
        if($record) {
1187
            $userMapper = UserMapper::getInstance($this->adapter);
1188
 
1189
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
1190
 
1191
 
1192
            $user = $userMapper->fetchOne($record->user_id);
1193
 
1194
            $item['unique'] = uniqid();
1195
            $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
1196
            $item['user_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
1197
            $item['user_name'] = $user->first_name . ' ' . $user->last_name;
1198
            $item['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
1199
            $item['comment'] = $record->comment;
1200
            $item['link_delete'] = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
1201
        }
1202
        return $item;
1203
    }
1204
 
1205
    /**
1206
     *
1207
     * @param string $path
1208
     * @return boolean
1209
     */
1210
    private function deletePath($path)
1211
    {
1212
        try {
1213
            if (is_dir($path)){
1214
                if ($dh = opendir($path)) {
1215
                    while (($file = readdir($dh)) !== false)
1216
                    {
1217
                        if($file == '.' || $file == '..') {
1218
                            continue;
1219
                        }
1220
                        unlink($path . DIRECTORY_SEPARATOR . $file);
1221
                    }
1222
                    closedir($dh);
1223
                }
1224
 
1225
                rmdir($path);
1226
            }
1227
            return true;
1228
        }
1229
        catch (\Throwable $e)
1230
        {
1231
            error_log($e->getTraceAsString());
1232
            return false;
1233
        }
1234
    }
1235
 
1236
 
1237
    /**
1238
     *
1239
     * @param Feed $feed
1240
     * @return array
1241
     */
1242
    private function deleteFeed($feed)
1243
    {
1244
        $feedMapper = FeedMapper::getInstance($this->adapter);
1245
        $feed->status = Feed::STATUS_DELETED;
1246
        if($feedMapper->update($feed)) {
1247
            $response = [
1248
                'success' => true,
1249
                'data' => 'LABEL_FEED_WAS_DELETED'
1250
            ];
1251
 
1252
        } else {
1253
            $response = [
1254
                'success' => false,
1255
                'data' => $feedMapper->getError()
1256
            ];
1257
        }
1258
 
1259
 
1260
        /*$commentMapper = CommentMapper::getInstance($this->adapter);
1261
        if($commentMapper->deleteAllByFeedId($feed->id)) {
1262
            if($feedMapper->delete($feed->id)) {
1263
                $target_path = $this->config['leaderslinked.fullpath.feed'] . DIRECTORY_SEPARATOR . $feed->id;
1264
                if(file_exists($target_path)) {
1265
                    $this->deletePath($target_path);
1266
                }
1267
 
1268
                $response = [
1269
                    'success' => true,
1270
                    'data' => 'LABEL_FEED_WAS_DELETED'
1271
                ];
1272
 
1273
            } else {
1274
                $response = [
1275
                    'success' => false,
1276
                    'data' => $feedMapper->getError()
1277
                ];
1278
            }
1279
        } else {
1280
            $response = [
1281
                'success' => false,
1282
                'data' => $commentMapper->getError()
1283
            ];
1284
 
1285
        }*/
1286
 
1287
        return $response;
1288
    }
1289
 
1290
 
1291
}