Proyectos de Subversion LeadersLinked - Backend

<?php
/**
 * 
 * Controlador: Mis Perfiles 
 * 
 */
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;

use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Form\CreateFeedForm;
use LeadersLinked\Form\CommentForm;
use LeadersLinked\Form\CommentAnswerForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Mapper\FeedMapper;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Model\Feed;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Library\Image;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;
use LeadersLinked\Mapper\LikeMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Library\Functions;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\UserType;

use LeadersLinked\Mapper\TopicMapper;
use LeadersLinked\Model\HighPerformanceTeamsGroupsMembers;
use LeadersLinked\Model\HighPerformanceTeamsGroups;
use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMembersMapper;
use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMapper;

class FeedController extends AbstractActionController
{
    /**
     *
     * @var AdapterInterface
     */
    private $adapter;
    
    
    /**
     *
     * @var AbstractAdapter
     */
    private $cache;
    
    /**
     *
     * @var  LoggerInterface
     */
    private $logger;

    
    /**
     *
     * @var array
     */
    private $config;
    
    /**
     *
     * @param AdapterInterface $adapter
     * @param AbstractAdapter $cache
     * @param LoggerInterface $logger
     * @param array $config
     */
    public function __construct($adapter, $cache , $logger,  $config)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;

    }
    
    /**
     * 
     * Generación del listado de perfiles
     * {@inheritDoc}
     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
     */
    public function indexAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
      

        $request = $this->getRequest();
        if($request->isGet()) {
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                    
                }
            }
            
            $formFeed = new CreateFeedForm($this->adapter);
           
            $this->layout()->setTemplate('layout/layout-backend');
            $viewModel = new ViewModel();
            $viewModel->setTemplate('leaders-linked/feeds/index.phtml');
            $viewModel->setVariables([
                'formFeed'      => $formFeed,
            ]);
            return $viewModel ;
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    
    public function commentAction()
    {
    

        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            if($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }
            
            $dataPost = $request->getPost()->toArray();
            $form = new CommentForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);
                
                $dataPost = (array) $form->getData();
                $comment = new Comment();
                $comment->comment = $dataPost['comment'];
                $comment->feed_id = $feed->id;
                
                if($feed->type=='hptg'){
                    $comment->user_id = $currentUser->id;
                } else if($feed->type=='mytq'){
                    $comment->user_id = $currentCompany->id;
                }
                else{
                    $comment->user_id = $owner->user_id;
                }
                
                $commentMapper = CommentMapper::getInstance($this->adapter);
                if($commentMapper->insert($comment)) {
                    
                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
                    
                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);
                    
                    $response = [
                        'success'   => true,
                        'data'   => $this->renderComment($comment->id),
                        'total_comments' => $total_comments
                    ];
                    
                    return new JsonModel($response);
                    
                } else {
                    
                    $response = [
                        'success'   => false,
                        'data'   => $commentMapper->getError()
                    ];
                    
                    return new JsonModel($response);
                }
                
            } else {
                $message = '';;
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    foreach( $field_messages as $key => $value)
                    {
                        $message = $value;
                    }
                }
                
                $response = [
                    'success'   => false,
                    'data'   => $message
                ];
                
                return new JsonModel($response);
            }
            
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($response);
        }
        
        
    }

    public function answerAction()
    {
    
       
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        
        $id = $this->params()->fromRoute('id');
        $comment_uuid = $this->params()->fromRoute('comment');
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            if($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }
           
            $dataPost = $request->getPost()->toArray();
            $form = new CommentAnswerForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);
                
                $dataPost = (array) $form->getData();
                $answer = new Comment();
                $answer->comment = $dataPost['answer'];
                $answer->feed_id = $feed->id;
                
                if($feed->type=='hptg'){
                    $answer->user_id = $currentUser->id;

                }else{
                    $answer->user_id = $owner->user_id;

                }

                $commentMapper = CommentMapper::getInstance($this->adapter);
                $comment=$commentMapper->fetchOneByUuid($comment_uuid);
                $answer->parent_id = $comment->id;
                
                if($commentMapper->insert($answer)) {
                    
                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
                    
                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);
                    
                    $response = [
                        'success'   => true,
                        'data'   => $this->renderComment($answer->id),
                        'total_comments' => $total_comments
                    ];
                    
                    return new JsonModel($response);
                    
                } else {
                    
                    $response = [
                        'success'   => false,
                        'data'   => $commentMapper->getError()
                    ];
                    
                    return new JsonModel($response);
                }
                
            } else {
                $message = '';;
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    foreach( $field_messages as $key => $value)
                    {
                        $message = $value;
                    }
                }
                
                $response = [
                    'success'   => false,
                    'data'   => $message
                ];
                
                return new JsonModel($response);
            }
            
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($response);
        }
        
        
    }

    
    
    public function commentDeleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $id = $this->params()->fromRoute('id');
            $comment = $this->params()->fromRoute('comment');
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            if($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }
            
            $commentMapper = CommentMapper::getInstance($this->adapter);
            $comment = $commentMapper->fetchOneByUuid($comment);
                
            if($comment && $comment->feed_id == $feed->id) {
                $comment->status = Comment::STATUS_DELETED;
                if($commentMapper->update($comment)) {
                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
                        
                    $feed = $feedMapper->fetchOne($comment->feed_id);
                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);
                        
                        
                        
                        
                        
                    $response = [
                        'success' => true,
                        'data' => [ 
                            'message' => 'LABEL_COMMENT_WAS_DELETED',
                            'total_comments' => $total_comments
                        ]    
                   ];
                } else {
                    $response = [
                        'success' => false,
                        'data' => $commentMapper->getError()
                    ];
                }
                    
            } else {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_COMMENT_NOT_FOUND'
                ];
            }

        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function deleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        if($request->isPost()) {

            
            $id =  $this->params()->fromRoute('id');
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            if($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed->status = Feed::STATUS_DELETED;
            if($feedMapper->update($feed)) {
                $response = [
                    'success' => true,
                    'data' => 'LABEL_FEED_WAS_DELETED'
                ];
                
            } else {
                $response = [
                    'success' => false,
                    'data' => $feedMapper->getError()
                ];
            }

            
            return new JsonModel($response);
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function addAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        $myt_id =  $this->params()->fromRoute('myt_id');
        $hptg_uuid =  $this->params()->fromRoute('hptg_id');

        $request = $this->getRequest();
        if($request->isPost()) {
            

            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            
            $form = new CreateFeedForm($this->adapter);
            
            $form->setData($dataPost);
          
            if($form->isValid()) {
                
                
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $company = $companyMapper->fetchOne($currentCompany->id);
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $owner = $companyUserMapper->fetchOwnerByCompanyId($company->id);
                
                $dataPost['priority'] =  isset($dataPost['priority']) ? Feed::PRIORITY_URGENT  : '';
           
                
                $hydrator = new ObjectPropertyHydrator();
                $feed = new Feed();
                $hydrator->hydrate($dataPost, $feed);
                if($hptg_uuid){

                   
              
                    $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                    $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($hptg_uuid);
                    
                    if (!$highPerformanceTeamsGroups) {
                        $data = [
                            'success' => false,
                            'data' => 'ERROR_RECORD_NOT_FOUND'
                        ];

                        return new JsonModel($data);
                    }

                    if($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {

                        return new JsonModel([
                            'success' => false,
                            'data' => 'ERROR_UNAUTHORIZED'
                        ]);

                    } 

                    $highPerformanceTeamsGroupsMemberMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);
                    $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMemberMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);
                    if($highPerformanceTeamsGroupsMember) {
                        if($highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED || $highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN ){
                            $id =  $highPerformanceTeamsGroups->id;
                        }else{

                            return new JsonModel([
                                'success' => false,
                                'data' => 'ERROR_UNAUTHORIZED'
                            ]);
                        }
                            
                    } else {

                        return new JsonModel([
                            'success' => false,
                            'data' => 'ERROR_RECORD_NOT_FOUND'
                        ]);
                    }
                    $topic_uuid =  $this->params()->fromRoute('topic_id');
                    if($topic_uuid){
                        $topicMapper = TopicMapper::getInstance($this->adapter);
                        $topic = $topicMapper->fetchOneByUuid($topic_uuid);
                        if($topic){
                            $feed->topic_id = $topic->id;
                        }else{
                            return new JsonModel([
                                'success' => false,
                                'data' => 'ERROR_RECORD_NOT_FOUND'
                            ]);
                        }
                       
                    }
                   

                    $feed->company_id       = $currentCompany->id;
                    $feed->group_id         = null;
                    $feed->high_performance_group_id = $id;
                    $feed->user_id          = $currentUser->id;
                    $feed->type             = Feed::TYPE_HPTG;
                    $feed->posted_or_shared = Feed::POSTED;
                    $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;

                } else if($myt_id){
                    $feedMapper = FeedMapper::getInstance($this->adapter);
                    $myt  = $feedMapper->fetchOneByUuid($myt_id);
                    $feed->company_id       = $currentCompany->id;
                    $feed->group_id         = null;
                    $feed->user_id          = $owner->user_id;
                    $feed->myt_id           = $myt->id;
                    $feed->related_feed     = $myt->id;
                    $feed->type             = Feed::TYPE_MYT_ANSWER;
                    $feed->posted_or_shared = Feed::POSTED;
                    $feed->shared_with      = Feed::SHARE_WITH_PUBLIC;
                }else{
                    $feed->company_id       = $currentCompany->id;
                    $feed->group_id         = null;
                    $feed->user_id          = $owner->user_id;
                    $feed->type             = Feed::TYPE_COMPANY;
                    $feed->posted_or_shared = Feed::POSTED;
                    $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;
                }
                
                

              
                $feed->total_comments   = 0;
                $feed->total_shared     = 0;
                
                
                $files = $this->getRequest()->getFiles()->toArray();
                $file_type = '';
                if(isset($files['file']) && empty($files['file']['error'])) {
                    $feed_tmp_filename  = $files['file']['tmp_name'];
                    $feed_filename      = $this->normalizeString($files['file']['name']);
                    
                    $mime_type = mime_content_type($feed_tmp_filename);
                    if($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {
                        $file_type = Feed::FILE_TYPE_IMAGE;
                    } else if($mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {
                        $file_type = Feed::FILE_TYPE_VIDEO;
                    } else if($mime_type == 'application/pdf') {
                        $file_type = Feed::FILE_TYPE_DOCUMENT;
                    }
                }
             
                
                $feedMapper = FeedMapper::getInstance($this->adapter);
                $result = $feedMapper->insert($feed);
                
               
                if($result) {
                    
                    $feed = $feedMapper->fetchOne($feed->id);
                    
                    if( $file_type == Feed::FILE_TYPE_DOCUMENT) {
                        try {
                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                            if(!file_exists($target_path)) {
                                mkdir($target_path, 0755);
                            }
                            
                            $full_filename = $target_path  . DIRECTORY_SEPARATOR .$feed_filename;
                            $result = move_uploaded_file($feed_tmp_filename , $full_filename);
                            if($result) {
                                
                                $feed->file_type = $file_type;
                                $feed->file_name = basename($feed_filename);
                                $feedMapper->update($feed);
                            } else {
                                error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );
                            }
                        } catch(\Throwable $e) {
                            error_log($e->getTraceAsString());
                        }
                    }
                    if( $file_type == Feed::FILE_TYPE_IMAGE) {
                        try {
                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                            if(!file_exists($target_path)) {
                                mkdir($target_path, 0755);
                            }
                            
                            list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);
                            
                            $feed_filename = substr($feed_filename, 0, strrpos($feed_filename, '.'))  . '.png';
                            $crop_to_dimensions = false;
                            if(Image::uploadImage($feed_tmp_filename, $target_path, $feed_filename, $target_width, $target_height, $crop_to_dimensions )) {
                                $feed->file_type = $file_type;
                                $feed->file_name = basename($feed_filename);
                                $feedMapper->update($feed);
                            }
                        } catch(\Throwable $e) {
                            error_log($e->getTraceAsString());
                        }
                    }
                    if( $file_type == Feed::FILE_TYPE_VIDEO) {
                        try {
                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                            if(!file_exists($target_path)) {
                                mkdir($target_path, 0755);
                            }
                            
                            $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;
                            
                            $result = move_uploaded_file($feed_tmp_filename , $full_filename);
                            if($result) {
                                
                                $size = $this->config['leaderslinked.image_sizes.feed_image_size'];
                                $getFromSecound = 2;
                                
                                //extracción del cover
                                $generateFileName = substr($feed_filename, 0, strrpos($feed_filename, '.'));
                                $generateFile =  $target_path  . DIRECTORY_SEPARATOR . $generateFileName .  '.png';
                                $cmd            = "/usr/bin/ffmpeg -i $full_filename -an -ss $getFromSecound -s $size $generateFile";
                                exec($cmd);
                                
                                
                                $feed->file_type = $file_type;
                                $feed->file_name = basename($feed_filename);
                                $feed->file_image_preview = basename($generateFile);
                                $feedMapper->update($feed);
                                
                                $videoConvert = new VideoConvert();
                                $videoConvert->filename = $full_filename;
                                $videoConvert->type = VideoConvert::TYPE_FEED;
                                
                                $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
                                $videoConvertMapper->insert($videoConvert);
                            } else {
                                error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );
                            }
                        } catch(\Throwable $e) {
                            error_log($e->getTraceAsString());
                        }
                    }
                    
                    
                    $response = [
                        'success'   => true,
                        'data'   => $this->renderFeed($feed->id)
                    ];
                   
                } else {
                    $response = [
                        'success'   => false,
                        'data'   => $feedMapper->getError()
                    ];
                }
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                $response = [
                    'success'   => false,
                    'data'   => $messages
                ];
            }
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    
    public function timelineAction() {
       
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
       
      
       

        $request = $this->getRequest();
        if($request->isGet()) {
             
            
            $page = (int) $this->params()->fromQuery('page');
            $type   = $this->params()->fromRoute('type');
            $topic_uuid   = $this->params()->fromRoute('topic_id');
            $urgent   = $this->params()->fromRoute('urgent');
            $myt_id =  $this->params()->fromRoute('myt_id');
            $hptg_uuid =  $this->params()->fromRoute('hptg_id');

           
            if($hptg_uuid){

                
                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($hptg_uuid);
                
                if (!$highPerformanceTeamsGroups) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];

                    return new JsonModel($data);
                }

                if($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {

                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);

                } 

                $highPerformanceTeamsGroupsMemberMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMemberMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);
                if($highPerformanceTeamsGroupsMember) {
                    if($highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED || $highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN ){
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                        $select->columns(['id']);
                        $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                        $select->where->equalTo('company_id',$currentCompany->id);
                        $select->where->equalTo('high_performance_group_id',$highPerformanceTeamsGroups->id);
                       
                     
                        if(isset($topic_uuid)){
                            $topicMapper = TopicMapper::getInstance($this->adapter);
                            $topic = $topicMapper->fetchOneByUuid($topic_uuid);
                            if($topic){
                                if($topic->status!='a'){
                                    return new JsonModel([
                                        'success' => false,
                                        'data' => 'ERROR_YOU_DO_NOT_HAVE_ACCESS'
                                    ]);
                                }
                                $select->where->equalTo('topic_id',$topic->id);
                          
                            }else{
                                return new JsonModel([
                                    'success' => false,
                                    'data' => 'ERROR_RECORD_NOT_FOUND'
                                ]);
                            }
                        }else{
                            if(isset($urgent)){
                                $select->where->equalTo('priority', Feed::PRIORITY_URGENT);
                            }else{
                                $select->where->IsNull('topic_id');
                            }
                            
                        }
           
                        
                        $select->where->and->equalTo('type', Feed::TYPE_HPTG);
                        $select->order('added_on desc');

                    }else{
                        return new JsonModel([
                            'success' => false,
                            'data' => 'ERROR_UNAUTHORIZED'
                        ]);
                    }
                        
                } else {

                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ]);
                }



                

            }else if($myt_id){
                $feedMapper = FeedMapper::getInstance($this->adapter);
                $myt  = $feedMapper->fetchOneByUuid($myt_id);
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('company_id',$currentCompany->id);
                $select->where->equalTo('myt_id', $myt->id);
                $select->where->and->equalTo('type', Feed::TYPE_MYT_ANSWER);
                $select->order('added_on desc');

            }else{
                
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('company_id',$currentCompany->id);
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
                $select->order('added_on desc');
            }
           
            
            
            $dbSelect = new DbSelect($select, $this->adapter);
            $paginator = new Paginator($dbSelect);
            $paginator->setCurrentPageNumber($page ? $page : 1);
            $paginator->setItemCountPerPage(10);
            
            $items = [];
            $feeds = $paginator->getCurrentItems();
            
            foreach($feeds as $feed)
            {
                $items[] = $this->renderFeed($feed->id);
            }
            
            $response = [
                'success' => true,
                'data' => [
                    'total' => [
                        'count' => $paginator->getTotalItemCount(),
                        'pages' => $paginator->getPages()->pageCount,
                    ],
                    'current' => [
                        'items'    => $items,
                        'page'     => $paginator->getCurrentPageNumber(),
                        'count'    => $paginator->getCurrentItemCount(),
                    ]
                ]
            ];
            
            return new JsonModel($response);
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        
        
        return new JsonModel($response);
    }
    
    public function oneFeedAction(){
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();
        if($request->isGet()) {
            
            $feed_uuid =  $this->params()->fromRoute('id');
            $myt_id =  $this->params()->fromRoute('id');
           
            if(!isset($feed_uuid)){
                    $data = [
                        'success'   => false,
                        'data'   => 'ERROR_INVALID_PARAMETER'
                    ];
                    
                    return new JsonModel($data);
            }
                   
            $items = [];
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed  = $feedMapper->fetchOneByUuid($feed_uuid);

            if (!$feed) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_RECORD_NOT_FOUND'
                ];
        
                return new JsonModel($data);
            }      
            
            if ($feed->type=='mytq'){
                
                $items = $this->renderFeed($feed->id,$myt_id);

                $response = [
                    'success' => true,
                    'data' => [
                        'item' =>$items,
                        'feed_title'=>$feed->title,
                        'topic_title'=>$feed->description
                    ]
                ];
 
            } else if ($feed->type=='myta'){
                
                $items = $this->renderFeed($feed->id,$myt_id);

                $response = [
                    'success' => true,
                    'data' => [
                        'item' =>$items,
                        'feed_title'=>$feed->title,
                        'topic_title'=>$feed->description
                    ]
                ];
 
            }else if($feed->type=='hptg'){

                $group_uuid =  $this->params()->fromRoute('group_id');
                $topic_uuid   = $this->params()->fromRoute('topic_id');

                if(!isset($topic_uuid)){
                
                    $data = [
                        'success'   => false,
                        'data'   => 'ERROR_INVALID_PARAMETER'
                    ];
                    
                    return new JsonModel($data);
                }
                if(!isset($group_uuid)){
                
                    $data = [
                        'success'   => false,
                        'data'   => 'ERROR_INVALID_PARAMETER'
                    ];
                    
                    return new JsonModel($data);
                }
                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($group_uuid);
                        
                if (!$highPerformanceTeamsGroups) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];
            
                    return new JsonModel($data);
                }

                       
                if($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {
            
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);
            
                } 

                if($feed->high_performance_group_id!=$highPerformanceTeamsGroups->id){
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_METHOD_NOT_ALLOWED'
                    ]);
                }
                
                $topicMapper = TopicMapper::getInstance($this->adapter);
                $topic = $topicMapper->fetchOneByUuid($topic_uuid);

                if (!$topic) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];
            
                    return new JsonModel($data);
                }    

                if($feed->topic_id!=$topic->id){
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_METHOD_NOT_ALLOWED'
                    ]);
                }  

                $items = $this->renderFeed($feed->id,$group_uuid);   
            
                $response = [
                    'success' => true,
                    'data' => [
                        'item' =>$items,
                        'topic_title'=>$topic->title,
                        'feed_title'=>$feed->title
                    ]
                ];
            }
            
            return new JsonModel($response);
        }
    }
    /**
     *
     * @param string $str
     * @return string
     */
    private function normalizeString ($str = ''){
        $basename  = substr($str, 0, strrpos($str, '.'));
        $basename  = str_replace('.', '-', $basename);
        
        $extension  = substr($str, strrpos($str, '.'));
        
        $str = $basename . $extension;
        
        $str = strip_tags($str);
        $str = preg_replace('/[\r\n\t ]+/', ' ', $str);
        $str = preg_replace('/[\"\*\/\:\<\>\?\'\|\,]+/', ' ', $str);
        $str = strtolower($str);
        $str = html_entity_decode( $str, ENT_QUOTES, "utf-8" );
        $str = htmlentities($str, ENT_QUOTES, "utf-8");
        $str = preg_replace("/(&)([a-z])([a-z]+;)/i", '$2', $str);
        $str = str_replace(' ', '-', $str);
        $str = rawurlencode($str);
        $str = str_replace('%', '-', $str);
        return trim(strtolower($str));
    }
    
    
    
    /**
     *
     * @param int $feed_id
     * @param Company $company
     * @return array
     */
    private function renderFeed($feed_id,$group_uuid="",$myt_id="")
    {
        
        $sandbox = $this->config['leaderslinked.runmode.sandbox'];
        if($sandbox) {
            $company_profile_url = $this->config['leaderslinked.frontend.sandbox_company_profile'];
            $user_profile_url = $this->config['leaderslinked.frontend.sandbox_user_profile'];
            
        } else {
            $company_profile_url = $this->config['leaderslinked.frontend.production_company_profile'];
            $user_profile_url = $this->config['leaderslinked.frontend.production_user_profile'];
        } 
        
        

        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOne($currentCompany->id);
        
        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
        $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);
        
        
        
        $acl = $this->getEvent()->getViewModel()->getVariable('acl');
        
        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($feed_id);
        

        $params = [
            'id' => $feed->uuid
        ];

        
        $item = [
            'feed_unique' => uniqid(),
            'feed_uuid' => $feed->uuid,
            'feed_delete_url' =>  $this->url()->fromRoute('feeds/delete',  $params),
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
            'feed_priority'=> $feed->priority,
        ];
        if($feed->type == Feed::TYPE_HPTG)
        {
            
                $uuid =  $this->params()->fromRoute('hptg_id');
                if($group_uuid!=''){
                    $uuid=$group_uuid;
                }
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOne($feed->user_id);
                $item['owner_url'] =  str_replace('[uuid]', $user->uuid, $user_profile_url);
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
                $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($uuid);
           
                if (!$highPerformanceTeamsGroups) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];
        
                    return new JsonModel($data);
                }
                if($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {

                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);

                } 
                $highPerformanceTeamsGroupsMembersMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMembersMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);
                if(!$highPerformanceTeamsGroupsMember) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ]);
                }
                if($feed->user_id == $currentUser->id||$highPerformanceTeamsGroupsMember->type!=HighPerformanceTeamsGroupsMembers::TYPE_USER) {
                    $item['feed_delete_url'] = $this->url()->fromRoute('feeds/delete',  $params);
                }else{
                    $item['feed_delete_url'] = '';
                }
       
        }else if($feed->type == Feed::TYPE_MYT_QUESTION){
            $uuid =  $this->params()->fromRoute('myt_id');
                if($myt_id!=''){
                    $uuid=$myt_id;
                }
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOne($feed->user_id);
            $item['feed_delete_url'] = $this->url()->fromRoute('feeds/delete',  $params);
            $item['owner_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'user', 'filename' => $company->image]);
            $item['owner_name'] = $company->name;
        } else if($feed->type == Feed::TYPE_MYT_ANSWER){
            $uuid =  $this->params()->fromRoute('myt_id');
                if($myt_id!=''){
                    $uuid=$myt_id;
                }
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOne($feed->user_id);
            $item['feed_delete_url'] = $this->url()->fromRoute('feeds/delete',  $params);
            $item['owner_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'user', 'filename' => $company->image]);
            $item['owner_name'] = $company->name;
        }else {
            $item['feed_delete_url'] = $this->url()->fromRoute('feeds/delete',  $params);
            $item['owner_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]);
            $item['owner_name'] = $company->name;
        }
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($feed->user_id);
        

        $item['owner_description'] = strip_tags($feed->description, 'p');        
        $item['owner_shared'] = $feed->total_shared;
        $item['owner_comments'] = $feed->total_comments;
        
        
        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $feed->added_on);
        $item['owner_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
        
        if($feed->file_type == Feed::FILE_TYPE_IMAGE) {
            $item['owner_file_image'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
            
        }
        if($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {
            $item['owner_file_document'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
        }
        if($feed->file_type == Feed::FILE_TYPE_VIDEO) {
            $item['owner_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_image_preview]);
            $item['owner_file_video'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
        }
        if($feed->file_type == Feed::FILE_TYPE_MEETING) {
            $dt = \DateTime::createFromFormat('Y-m-d', $feed->date);
            $dt2 = \DateTime::createFromFormat('H:i:s', $feed->time);
            $item['owner_meeting'] =  true;
            $item['owner_meeting_date'] =  $dt->format('d/m/Y');
            $item['owner_meeting_time'] =  $dt2->format('h:i a');
            $item['owner_meeting_link_type'] =  $feed->link_type;
            $item['owner_meeting_link_name'] =  $feed->link_name;
            
        }
        
        

        
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $records = $commentMapper->fetchAllPublishedByFeedId($feed->id);
        
        
        $comments = [];
        $comment_count=0;
        foreach($records as $record)
        {
            $user = $userMapper->fetchOne($record->user_id);
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);

            $comment = [];
            $comment['unique'] = uniqid();
            $comment_count++;
            $comment['comment_index']=$comment_count;
            $user = $userMapper->fetchOne($record->user_id);
            if($user->id == $owner->user_id) {
                $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image ]);
                $comment['user_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
                $comment['user_name'] = $company->name;
            } else {
                $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
                $comment['user_url'] = str_replace('[uuid]', $user->uuid, $user_profile_url);
                $comment['user_name'] = $user->first_name . ' ' . $user->last_name;
            }
            if($feed->type == Feed::TYPE_HPTG)
            {
                if($record->user_id == $currentUser->id||$highPerformanceTeamsGroupsMember->type!=HighPerformanceTeamsGroupsMembers::TYPE_USER) {
                    $comment['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
                }else{
                    $comment['link_delete'] = '';
                }
            }else{
                $comment['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
            }
            
            $comment['link_answer_add'] = $this->url()->fromRoute('feeds/comments/answer',['id' => $feed->uuid, 'comment' => $record->uuid ]);
            $comment['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
            $comment['comment'] = $record->comment;
            
            $records2 = $commentMapper->fetchAllPublishedByCommentId($record->id);
            $answers = [];
            $contador=0;
            foreach($records2 as $record2)
            {
                $user = $userMapper->fetchOne($record2->user_id);
                $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record2->added_on);

                $answer = [];
                $answer['unique'] = uniqid();
                
                
                $user = $userMapper->fetchOne($record2->user_id);
                if($user->id == $owner->user_id) {
                    $answer['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image ]);
                    $answer['user_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
                    $answer['user_name'] = $company->name;
                } else {
                    $answer['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
                    $answer['user_url'] = str_replace('[uuid]', $user->uuid, $user_profile_url);
                    $answer['user_name'] = $user->first_name . ' ' . $user->last_name;
                }
                if($feed->type == Feed::TYPE_HPTG)
                {
                    if($record2->user_id == $currentUser->id||$highPerformanceTeamsGroupsMember->type!=HighPerformanceTeamsGroupsMembers::TYPE_USER) {
                        $answer['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record2->uuid ]);
                    }else{
                        $answer['link_delete'] ='';
                    }
                }else{
                    $answer['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record2->uuid ]);
                }
                
                $answer['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
                $answer['comment'] = $record2->comment;
                
                $records2 = $commentMapper->fetchAllPublishedByCommentId($record2->id);

                $contador++;
                array_push($answers, $answer);
            }
            $comment['number_answers']=$contador;
            $comment['answers'] = $answers;
            array_push($comments, $comment);
        }
        $item['comment_add_url'] = $this->url()->fromRoute('feeds/comments', ['id' => $feed->uuid]);
            $item['comments'] = $comments;
        
        
        
        return $item;
    }
    
    /**
     *
     * @param int $comment_id
     * @return array
     */
    private function renderComment($comment_id)
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOne($currentCompany->id);
        
        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
        $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id); 
        
        
        
        $sandbox = $this->config['leaderslinked.runmode.sandbox'];
        if($sandbox) {
            $company_profile_url = $this->config['leaderslinked.frontend.sandbox_company_profile'];
            $user_profile_url = $this->config['leaderslinked.frontend.sandbox_user_profile'];
        } else {
            $company_profile_url = $this->config['leaderslinked.frontend.production_company_profile'];
            $user_profile_url = $this->config['leaderslinked.frontend.production_user_profile'];
        } 
        
        
        $item = [];
        
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $record = $commentMapper->fetchOne($comment_id);
        
        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($record->feed_id);
        
        if($record) {
            $userMapper = UserMapper::getInstance($this->adapter);
            
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
            
            
            $item = [];
            $item['unique'] = uniqid();
            
            
            $user = $userMapper->fetchOne($record->user_id);
            if($user->id == $owner->user_id) {
                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image ]);
                $item['user_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);
                $item['user_name'] = $company->name;
            } else {
                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
                $item['user_url'] = str_replace('[uuid]', $user->uuid, $user_profile_url);
                $item['user_name'] = $user->first_name . ' ' . $user->last_name;
            }
            
            
          
            $item['link_answer_add'] = $this->url()->fromRoute('feeds/comments/answer',['id' => $feed->uuid, 'comment' => $record->uuid ]);
            $item['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
            $item['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
            $item['comment'] = $record->comment;
            
        }
        return $item;
    }
    
    /**
     *
     * @param string $path
     * @return boolean
     */
    private function deletePath($path)
    {
        try {
            if (is_dir($path)){
                if ($dh = opendir($path)) {
                    while (($file = readdir($dh)) !== false)
                    {
                        if($file == '.' || $file == '..') {
                            continue;
                        }
                        unlink($path . DIRECTORY_SEPARATOR . $file);
                    }
                    closedir($dh);
                }
                
                rmdir($path);
            }
            return true;
        }
        catch (\Throwable $e)
        {
            error_log($e->getTraceAsString());
            return false;
        }
    }

}