Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 3298 | Rev 3671 | Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
use Laminas\Mvc\Controller\AbstractActionController;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\UserPasswordMapper;
use LeadersLinked\Form\AccountSetting\NotificationSettingForm;
use LeadersLinked\Mapper\UserNotificationSettingMapper;

use LeadersLinked\Form\AccountSetting\ChangePasswordForm;
use LeadersLinked\Form\AccountSetting\ChangeImageForm;
use LeadersLinked\Library\Image;
use LeadersLinked\Form\AccountSetting\LocationForm;
use LeadersLinked\Model\Location;
use LeadersLinked\Model\User;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Form\AccountSetting\PrivacySettingForm;
use LeadersLinked\Mapper\UserProfileMapper;
use LeadersLinked\Form\AccountSetting\BasicForm;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Mapper\ProfileVisitMapper;
use LeadersLinked\Mapper\GroupMemberMapper;
use LeadersLinked\Model\GroupMember;
use LeadersLinked\Mapper\UserExperienceMapper;
use LeadersLinked\Model\UserExperience;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Model\Group;
use Laminas\Db\Sql\Expression;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Model\UserType;
use LeadersLinked\Mapper\CompanyMicrolearningCapsuleUserMapper;
use LeadersLinked\Model\Notification;
use LeadersLinked\Mapper\NotificationMapper;
use LeadersLinked\Mapper\EmailTemplateMapper;
use LeadersLinked\Model\EmailTemplate;
use LeadersLinked\Library\QueueEmail;
use LeadersLinked\Mapper\PostMapper;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\Connection;
use Laminas\Navigation\Navigation;

class HelperController extends AbstractActionController
{
    /**
     *
     * @var AdapterInterface
     */
    private $adapter;
    
    
    /**
     *
     * @var AbstractAdapter
     */
    private $cache;
    
    /**
     *
     * @var  LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
    
    /**
     *
     * @var array
     */
    private $navigation;
    
    /**
     *
     * @param AdapterInterface $adapter
     * @param AbstractAdapter $cache
     * @param LoggerInterface $logger
     * @param array $config
     * @param array $navigation
     */
    public function __construct($adapter, $cache , $logger, $config, $navigation)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->navigation   = $navigation;
    }
    
    
    /**
     * Recuperamos las personas que pueda conocer
     * tiene que enviarse un petición GET a la siguiente url: /helpers/people-you-may-know
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del usuario encriptado',
     *        'name'    => 'nombre del usuario',
     *        'image'   => 'imagen del usuario',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function peopleYouMayKnowAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
    
            $connectionMapper = ConnectionMapper::getInstance($this->adapter);
            $first_degree_connections_ids = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
            $first_degree_connections_ids = $first_degree_connections_ids ? $first_degree_connections_ids : [0];
            

            
            $second_degree_connections_ids = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
            $second_degree_connections_ids = $second_degree_connections_ids ? $second_degree_connections_ids : [0];
            

           
            
            /*Usuarios de la empresas donde trabajo o soy dueño */
            $company_user_ids = [];
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            
            $records = $companyUserMapper->fetchAllByUserId($currentUser->id);
            foreach($records as $record)
            {
                
                if($record->status != CompanyUser::STATUS_ACCEPTED) {
                    continue;
                }
                
                $otherUsers = $companyUserMapper->fetchAllByCompanyId($record->company_id);
                foreach($otherUsers as $otherUser)
                {
                    if($currentUser->id != $otherUser->user_id && $otherUser->creator == CompanyUser::CREATOR_NO && $otherUser->status == CompanyUser::STATUS_ACCEPTED) {
                        
                        if(!in_array($otherUser->user_id, $company_user_ids)) {
                            array_push($company_user_ids, $otherUser->user_id);
                        }
                    }
                }
            }
            $company_user_ids =  $company_user_ids ? $company_user_ids : [0];
            
            /* Usuario de los grupos donde soy dueño o participo */
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            
            $group_member_ids = [];
            
            $records = $groupMemberMapper->fetchAllByUserId($currentUser->id);
            foreach($records as $record)
            {
                if($record->status != GroupMember::STATUS_ACCEPTED) {
                    continue;
                }
                
                $otherUsers = $groupMemberMapper->fetchAllByGroupId($record->group_id);
                foreach($otherUsers as $otherUser)
                {
                    if($currentUser->id != $otherUser->user_id && $otherUser->status == GroupMember::STATUS_ACCEPTED) {
                        
                        if(!in_array($otherUser->user_id, $group_member_ids)) {
                            array_push($group_member_ids, $otherUser->user_id);
                        }
                    }
                }
                
                
            }
            
            $group_member_ids = $group_member_ids ? $group_member_ids : [0];
            

            
            /* Usuarios con que comparto capsulas */ 
            $capsule_user_ids = [];
            $capsuleUserMapper = CompanyMicrolearningCapsuleUserMapper::getInstance($this->adapter);
            
            $company_ids = [];
            $records = $capsuleUserMapper->fetchAllActiveByUserId($currentUser->id);
            foreach($records as $record)
            {
                if(!in_array($record->company_id,$company_ids)) {
                    array_push($company_ids, $record->company_id);
                }
            }
            
      
            
            foreach($company_ids as $company_id)
            {
                $otherUsers = $capsuleUserMapper->fetchAllUserIdsForCapsulesActiveByCompanyId($company_id);
                foreach($otherUsers as $user_id)
                {
                    if($currentUser->id != $user_id ) {
                        
                        if(!in_array($user_id, $capsule_user_ids)) {
                            array_push($capsule_user_ids, $user_id);
                        }
                    }
                }
            }
            
            $capsule_user_ids = $capsule_user_ids ? $capsule_user_ids : [0];
            
            
            $other_users = array_unique(array_merge(
                $second_degree_connections_ids,
                $company_user_ids,
                $group_member_ids,
                $capsule_user_ids
            ));
            
            
            
            
            
           
            
            
            $items = [];
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $select = $queryMapper->getSql()->select();
            $select->columns(['id', 'uuid',  'first_name','last_name', 'image']);
            $select->from(['u' => UserMapper::_TABLE]);
            $select->where->in('u.id', $other_users);
            $select->where->notIn('u.id', $first_degree_connections_ids);
            $select->where->notEqualTo('u.id', $currentUser->id);
            $select->where->equalTo('u.status', User::STATUS_ACTIVE);
            $select->where->in('u.usertype_id', [UserType::ADMIN, UserType::USER]);
            $select->order(['first_name','last_name']);
                
                //echo $select->getSqlString($this->adapter->platform); exit;
                
            $records = $queryMapper->fetchAll($select);
            foreach($records as $record)
            {

                $relation = [];
                if(in_array($record['id'], $second_degree_connections_ids)) {
                    array_push($relation, 'LABEL_RELATION_TYPE_SECOND_GRADE');
                }
                if(in_array($record['id'], $company_user_ids)) {
                    array_push($relation, 'LABEL_RELATION_TYPE_COMPANY_USER');
                }      
                if(in_array($record['id'], $group_member_ids)) {
                    array_push($relation, 'LABEL_RELATION_TYPE_GROUP_MEMBER');
                }      
                if(in_array($record['id'], $capsule_user_ids)) {
                    array_push($relation, 'LABEL_RELATION_TYPE_CAPSULE_USER');
                }
                    
              
                $connection = $connectionMapper->fetchOneByUserId1AndUserId2($currentUser->id, $record['id']);
                
                $item = [
                    'id'    => $record['uuid'],
                    'name'  => trim($record['first_name'] . ' ' . $record['last_name']),
                    'image' => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']]),
                    'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid'] ]),
                    'relation' => $relation,
                    'link_cancel'   => '', 
                    'link_request'  => '',
                ];
                
                if($connection) {
                    switch($connection->status)
                    {
                        case Connection::STATUS_SENT :
                            $item['link_cancel'] = $this->url()->fromRoute('connection/delete',['id' => $record['uuid'] ]);
                            break;
                            
                        case Connection::STATUS_ACCEPTED : 
                            $item['link_cancel'] = $this->url()->fromRoute('connection/cancel',['id' => $record['uuid'] ]);
                            break;
                            
                        default :  
                            $item['link_request'] = $this->url()->fromRoute('connection/request',['id' => $record['uuid'] ]);
                            break;
                            
                    }
                    
                    
                } else {
                    $item['link_request'] = $this->url()->fromRoute('connection/request',['id' => $record['uuid'] ]);
                }
                
                    
                array_push($items, $item);
            }

            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }

    }
    
    /**
     * Recuperamos las personas que pueda conocer
     * tiene que enviarse un petición GET a la siguiente url: /helpers/people-viewed-profile/:user_profile_id
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del usuario encriptado',
     *        'name'    => 'nombre del usuario',
     *        'image'   => 'imagen del usuario',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function peopleViewedProfileAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $items = [];
            $user_profile_id = $this->params()->fromRoute('user_profile_id');
            
            $items = [];
            
            $mapper = QueryMapper::getInstance($this->adapter);
            $select = $mapper->getSql()->select(ProfileVisitMapper::_TABLE);
            $select->columns(['user_id' => new Expression('DISTINCT(visitor_id)')]);
            $select->where->equalTo('user_profile_id', $user_profile_id);
            $records = $mapper->fetchAll($select);

            if($records) {
                
                $user_ids = [];
                foreach($records as $record)
                {
                    array_push($user_ids, $record['user_id']);
                }
                
                $mapper = QueryMapper::getInstance($this->adapter);
                $select = $mapper->getSql()->select( UserMapper::_TABLE);
                $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
                $select->where->in('id', $user_ids);
                $select->where->equalTo('status',User::STATUS_ACTIVE);
                $select->order(['last_name ASC', 'first_name ASC']);
                
                $records = $mapper->fetchAll($select);
                foreach($records as $record)
                {
                    array_push($items, [
                        'id'        => $record['uuid'],
                        'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']]),
                        'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid'] ]),
                    ]);
                }
            }

            
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    
    /**
     * Recuperamos los seguidores de la empresa
     * tiene que enviarse un petición GET a la siguiente url: /helpers/company-follower/:company_id
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del usuario encriptado',
     *        'name'    => 'nombre del usuario',
     *        'image'   => 'imagen del usuario',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function companyFollowerAction()
    {

        
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $company_uuid  = $this->params()->fromRoute('company_id');
            
            $companyMapper = CompanyMapper::getInstance($this->adapter);
            $company = $companyMapper->fetchOneByUuid($company_uuid);
            
            $items = [];
            if($company && $company->status == Company::STATUS_ACTIVE) {
            
            
                //print_r($company);

                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                $records = $companyFollowerMapper->fetchAllByCompanyId($company->id);
                
                $ids = [];
                foreach($records as $record)
                {
                    if(!in_array($record->follower_id, $ids)) {
                        array_push($ids, $record->follower_id);
                    }
                }
                
                //print_r($records);
                
               
                if($ids) {
                    
                    $mapper = QueryMapper::getInstance($this->adapter);
                    $select = $mapper->getSql()->select(UserMapper::_TABLE);
                    $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
                    $select->where->in('id',$ids);
                    $select->where->equalTo('status',User::STATUS_ACTIVE);
                    $select->order(['last_name','first_name']);
                    
                    //echo $select->getSqlString($this->adapter->platform); exit;
                    
                    
                    
                    $records = $mapper->fetchAll($select);
                    foreach($records as $record)
                    {
                        
                        
                        array_push($items, [
                            'id'        => $record['uuid'],
                            'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
                            'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']]),
                            'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid'] ]),
                        ]);
                    }
                }
            }
            
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function companySuggestionAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $company_id = $this->params()->fromRoute('company_id');
            
            $companyMapper = CompanyMapper::getInstance($this->adapter);
            $company = $companyMapper->fetchOneByUuid($company_id);
            
            $items = [];
            if($company && $company->status == Company::STATUS_ACTIVE) {
                
                
                $mapper = QueryMapper::getInstance($this->adapter);
                $select = $mapper->getSql()->select(CompanyMapper::_TABLE);
                $select->columns(['id', 'uuid', 'name', 'image']);
                $select->where->notEqualTo('id', $company->id);
                $select->where->equalTo('status',Company::STATUS_ACTIVE);
                $select->where->equalTo('industry_id', $company->industry_id);
              //  $select->where->equalTo('company_size_id', $company->company_size_id);
                $select->order(['name']);
                
                
                //echo $select->getSqlString($this->adapter->platform); exit;
                
                $records = $mapper->fetchAll($select);
                foreach($records as $record)
                {
                    array_push($items, [
                        'id'        => $record['uuid'],
                        'name'      => trim($record['name']),
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'company', 'filename' => $record['image']]),
                        'profile'   => $this->url()->fromRoute('company/view', ['id' => $record['uuid'] ]),
                    ]);
                }
            }
            
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    /**
     * Recuperamos los miembros del grupo
     * tiene que enviarse un petición GET a la siguiente url: /helpers/group-members/:group_id
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del usuario encriptado',
     *        'name'    => 'nombre del usuario',
     *        'image'   => 'imagen del usuario',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function groupMembersAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $group_uuid = $this->params()->fromRoute('group_id');
            
            $groupMapper = GroupMapper::getInstance($this->adapter);
            $group = $groupMapper->fetchOneByUuid($group_uuid);
            
            $items = [];
            if($group && $group->status == Group::STATUS_ACTIVE) {
                
                $mapper = QueryMapper::getInstance($this->adapter);
                $select = $mapper->getSql()->select();
                $select->columns(['id', 'uuid', 'first_name', 'last_name', 'image']);
                $select->from(['u' => UserMapper::_TABLE]);
                $select->join(['gm' => GroupMemberMapper::_TABLE], 'gm.user_id = u.id ', ['user_id', 'status']);
                $select->join(['g' => GroupMapper::_TABLE], 'gm.group_id = g.id', ['group_uuid' => 'uuid']  );
                $select->where->equalTo('g.uuid', $group_uuid);
                
                if($group->user_id == $currentUser->id) {
                    $select->where->in('gm.status', [
                        GroupMember::STATUS_ACCEPTED, 
                        GroupMember::STATUS_ADDED_BY_ADMIN,
                        GroupMember::STATUS_AUTO_JOIN,
                        GroupMember::STATUS_JOINING_REQUESTED,
                    ]);
                } else {
                    $select->where->in('gm.status', [GroupMember::STATUS_ACCEPTED, GroupMember::STATUS_AUTO_JOIN]);
                } 
                
                
                $select->where->equalTo('u.status', User::STATUS_ACTIVE);
                $select->order(['last_name', 'first_name']);
                
                //echo $select->getSqlString($this->adapter->platform);
       
               

                
                $records = $mapper->fetchAll($select);
                foreach($records as $record)
                {
                    
                    $actions = [];
                    if($group->user_id == $currentUser->id) {
                        if($record['id'] != $currentUser->id) {
                          
                            
                            
                            switch($record['status'])
                            {
                                case GroupMember::STATUS_JOINING_REQUESTED :
                                    $actions['link_approve'] = $this->url()->fromRoute('helpers/group-members/approve', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
                                    $actions['link_reject'] = $this->url()->fromRoute('helpers/group-members/reject', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
                                    break;
                                    
                                case GroupMember::STATUS_ACCEPTED :
                                case GroupMember::STATUS_AUTO_JOIN :
                                case GroupMember::STATUS_ADDED_BY_ADMIN :
                                    $actions['link_cancel'] = $this->url()->fromRoute('helpers/group-members/cancel', ['group_id' => $group->uuid, 'user_id' => $record['uuid']]);
                                    break;
                            }
                        }
                
                        
              
                    }
                        
                    array_push($items, [
                        'id'        => $record['uuid'],
                        'name'      => trim($record['first_name'] . ' ' . $record['last_name']),
                        'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'user', 'filename' => $record['image']]),
                        'profile'   => $this->url()->fromRoute('profile/view', ['id' => $record['uuid']]),
                        'actions'   => $actions,
                        
                    ]);
                }
            }
            
            return new JsonModel([
                'success' => true,
                'data' => [
                    'items' => $items,
                    'link_invite' => $group->user_id == $currentUser->id ? $this->url()->fromRoute('helpers/group-members/invite',['group_id' => $group->uuid])  : '',
                ]
            ]);
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function groupMemberInviteAction()
    {

        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $group_uuid = $this->params()->fromRoute('group_id');
        
        $groupMapper = GroupMapper::getInstance($this->adapter);
        $group = $groupMapper->fetchOneByUuid($group_uuid);
        
        if(!$group) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_NOT_FOUND'
            ]);
        }
        
        if($group->status != Group::STATUS_ACTIVE) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
            ]);
        }
        
        if($currentUser->id != $group->user_id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
            ]);
        }
        
        
        $request = $this->getRequest();
        if($request->isGet()) {
            $search = filter_var($this->params()->fromQuery('search', ''));
            if(strlen($search) >= 3) {

                $userMapper = UserMapper::getInstance($this->adapter);
                $records  = $userMapper->fetchAllSuggestForInvitationByGroupId($group->id, $search);
                
                $users = [];
                foreach($records as $record)
                {
                    array_push($users, [
                        'value' => $record->uuid,
                        'text' => trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')'
                        
                    ]);
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => $users
                ]);
                
                
                
                
            } else {
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        
                    ]
                ]);
            } 
            
            

        } 
        else if($request->isPost()) {
            $uuid = $this->params()->fromPost('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->status != User::STATUS_ACTIVE) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_IS_INACTIVE'
                ]);
            }
            
            if($group->user_id == $user->id) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
            
            
            
            if($groupMember) {
                $result = false;
                
                switch($groupMember->status)
                {
                    case GroupMember::STATUS_ACCEPTED:
                    case GroupMember::STATUS_AUTO_JOIN: 
                        
                        return new JsonModel([
                            'success'   => false,
                            'data'      => 'ERROR_GROUP_YOU_ARE_MEMBER',
                        ]);
                        break;
                        
                        
                    case $groupMember->status == GroupMember::STATUS_REJECTED :
                    case $groupMember->status == GroupMember::STATUS_CANCELLED :
                        
                        $groupMember->status = GroupMember::STATUS_ADDED_BY_ADMIN;
                        $groupMember->joining_request_on = date('H-m-d H:i:s');
                        
                        $result = $groupMemberMapper->update($groupMember);
                        break;
                     
                    case GroupMember::STATUS_ADDED_BY_ADMIN : 
                    case  GroupMember::STATUS_JOINING_REQUESTED :
                        return new JsonModel([
                            'success'   => false,
                            'data'      => 'ERROR_GROUP_THERE_IS_A_PENDING_REQUEST'
                        ]);
                        break;
                        
                    default :     
                        return new JsonModel([
                            'success'   => false,
                            'data'      => 'ERROR_UNKNOWN_OPERATION'
                        ]);
                        break;
                        
                }

               
                    
                
                
                
            } else {
                
                
                
                $groupMember = new GroupMember();
                $groupMember->user_id = $user->id;
                $groupMember->group_id = $group->id;
                $groupMember->status = GroupMember::STATUS_ADDED_BY_ADMIN;
                $groupMember->joining_request_on = date('H-m-d H:i:s');
              
                $result = $groupMemberMapper->insert($groupMember);
                
                
            } 
            
            if($result) {
                
                $notification = new Notification();
                $notification->type     = Notification::TYPE_RECEIVE_INVITATION_GROUP;
                $notification->read     = Notification::NO;
                $notification->user_id  = $user->id;
                $notification->group_id = $group->id;
                $notification->message  = 'LABEL_NOTIFICATION_RECEIVE_INVITATION_GROUP';
                $notification->url      = $this->url()->fromRoute('group/view',['id' => $group->uuid]);
                
                $notificationMapper = NotificationMapper::getInstance($this->adapter);
                $notificationMapper->insert($notification);
                
                $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                $userNotification = $userNotificationMapper->fetchOne($user->id);
                
                if($userNotification && $userNotification->receive_invitation_group)
                {
                    $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                    $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_RECEIVE_INVITATION_GROUP);
                    
                    if($emailTemplate) {
                        $arrayCont = [
                            'firstname'             => $currentUser->first_name,
                            'lastname'              => $currentUser->last_name,
                            'other_user_firstname'  => $user->first_name,
                            'other_user_lastname'   => $user->last_name,
                            'company_name'          => '',
                            'group_name'            => $group->name,
                            'content'               => '',
                            'code'                  => '',
                            'link'                  => $this->url()->fromRoute('group/view', ['id' => $group->uuid], ['force_canonical' => true])
                        ];
                        
                        $email = new QueueEmail($this->adapter);
                        $email->processEmailTemplate($emailTemplate, $arrayCont, $user->email, trim($user->first_name . ' ' . $user->last_name));
                    }
                }
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_GROUP_REQUEST_SUCCESS'
                ]);
                
            } else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_GROUP_REQUEST_COULD_NOT_BE_SENT'
                ]);
                
            } 
            
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function  groupMemberCancelAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $group_uuid = $this->params()->fromRoute('group_id');
            $user_uuid  = $this->params()->fromRoute('user_id'); 
            
            $groupMapper = GroupMapper::getInstance($this->adapter);
            $group = $groupMapper->fetchOneByUuid($group_uuid);
            
            if(!$group) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_NOT_FOUND'
                ]);
            }
            
            if($group->status != Group::STATUS_ACTIVE) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
                ]);
            }
            
            if($currentUser->id != $group->user_id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($user_uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->id == $currentUser->id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
            if($groupMember) {
                
                if($groupMember->status == GroupMember::STATUS_ACCEPTED ||
                    $groupMember->status == GroupMember::STATUS_ADDED_BY_ADMIN ||
                    $groupMember->status == GroupMember::STATUS_AUTO_JOIN) {
                    
                    $groupMember->status = GroupMember::STATUS_CANCELLED;
                    if($groupMemberMapper->update($groupMember)) {

                        return new JsonModel([
                            'success' => true,
                            'data' =>  'LABEL_GROUP_MEMBER_CANCELLED_SUCCESS' 
                        ]);
                            
                    } else {
                        return new JsonModel([
                            'success' => true,
                            'data' =>    'LABEL_GROUP_MEMBER_CANCELLED_FAILED' 
                        ]);
                    }
                }
                
            } 
            
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_REQUEST_OR_MEMBER_NOT_FOUND_TO_CANCEL'
            ]);

            
            
            
            
        } else {
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function  groupMemberRejectAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $group_uuid = $this->params()->fromRoute('group_id');
            $user_uuid  = $this->params()->fromRoute('user_id');
            
            $groupMapper = GroupMapper::getInstance($this->adapter);
            $group = $groupMapper->fetchOneByUuid($group_uuid);
            
            if(!$group) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_NOT_FOUND'
                ]);
            }
            
            if($group->status != Group::STATUS_ACTIVE) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
                ]);
            }
            
            if($currentUser->id != $group->user_id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($user_uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->id == $currentUser->id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
            if($groupMember) {
                
                if($groupMember->status == GroupMember::STATUS_JOINING_REQUESTED) {
                        
                        $groupMember->status = GroupMember::STATUS_REJECTED;
                        if($groupMemberMapper->update($groupMember)) {
                            
                            return new JsonModel([
                                'success' => true,
                                'data' =>  'LABEL_GROUP_MEMBER_REJECTED_SUCCESS'
                            ]);
                            
                        } else {
                            return new JsonModel([
                                'success' => true,
                                'data' =>    'LABEL_GROUP_MEMBER_REJECTED_FAILED'
                            ]);
                        }
                    }
                    
            }
            
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_THERE_IS_NO_PENDING_REQUEST_TO_REJECT'
            ]);
            
            
            
            
            
        } else {
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function  groupMemberApproveAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $group_uuid = $this->params()->fromRoute('group_id');
            $user_uuid  = $this->params()->fromRoute('user_id');
            
            $groupMapper = GroupMapper::getInstance($this->adapter);
            $group = $groupMapper->fetchOneByUuid($group_uuid);
            
            if(!$group) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_NOT_FOUND'
                ]);
            }
            
            if($group->status != Group::STATUS_ACTIVE) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_ACTIVE'
                ]);
            }
            
            if($currentUser->id != $group->user_id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_IS_NOT_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($user_uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->id == $currentUser->id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_GROUP_YOU_ARE_THE_OWNER_OF_THIS_GROUP'
                ]);
            }
            
            
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $user->id);
            if($groupMember) {
                
                if($groupMember->status == GroupMember::STATUS_JOINING_REQUESTED) {
                    
                    $groupMember->status = GroupMember::STATUS_ACCEPTED;
                    if($groupMemberMapper->update($groupMember)) {
                        
                        
                        $notification = new Notification();
                        $notification->type     = Notification::TYPE_ACCEPT_MY_REQUEST_JOIN_GROUP;
                        $notification->read     = Notification::NO;
                        $notification->user_id  = $user->id;
                        $notification->group_id = $group->id;
                        $notification->message  = 'LABEL_NOTIFICATION_ACCEPT_MY_REQUEST_JOIN_GROUP';
                        $notification->url      = $this->url()->fromRoute('group/view', ['id' => $group->uuid]);
                        
                        $notificationMapper = NotificationMapper::getInstance($this->adapter);
                        $notificationMapper->insert($notification);
                        
                        $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                        $userNotification = $userNotificationMapper->fetchOne($user->id);
                        
                        if($userNotification && $userNotification->receive_invitation_group)
                        {
                            $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                            $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_ACCEPT_MY_REQUEST_JOIN_GROUP);
                            
                            if($emailTemplate) {
                                $arrayCont = [
                                    'firstname'             => $currentUser->first_name,
                                    'lastname'              => $currentUser->last_name,
                                    'other_user_firstname'  => $user->first_name,
                                    'other_user_lastname'   => $user->last_name,
                                    'company_name'          => '',
                                    'group_name'            => $group->name,
                                    'content'               => '',
                                    'code'                  => '',
                                    'link'                  => $this->url()->fromRoute('group/view', ['id' => $group->uuid], ['force_canonical' => true])
                                ];
                                
                                $email = new QueueEmail($this->adapter);
                                $email->processEmailTemplate($emailTemplate, $arrayCont, $user->email, trim($user->first_name . ' ' . $user->last_name));
                            }
                        }
                        
                        return new JsonModel([
                            'success' => true,
                            'data' =>  'LABEL_GROUP_MEMBER_APPROVED_SUCCESS'
                        ]);
                        
                    } else {
                        return new JsonModel([
                            'success' => true,
                            'data' =>    'LABEL_GROUP_MEMBER_APPROVED_FAILED'
                        ]);
                    }
                }
                
            }
            
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_GROUP_THERE_IS_NO_PENDING_REQUEST_TO_APPROVED'
            ]);
            
            
            
            
            
        } else {
            
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    
    /**
     * Recuperamos los grupos sugeridos
     * tiene que enviarse un petición GET a la siguiente url: /helpers/groups-suggestion/:group_id
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del grupo encriptado',
     *        'name'    => 'nombre del grupo',
     *        'image'   => 'imagen del grupo',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function groupsSuggestionAction()
    {

        $request = $this->getRequest();
        if($request->isGet()) {
            
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
         
            
            $connectionMapper = ConnectionMapper::getInstance($this->adapter);
            $first_degree_connections_ids = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
            $first_degree_connections_ids = $first_degree_connections_ids ? $first_degree_connections_ids : [0];
            
            
            
            $second_degree_connections_ids = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
            $second_degree_connections_ids = $second_degree_connections_ids ? $second_degree_connections_ids : [0];
            
            
            /*Usuarios de la empresas donde trabajo o soy dueño */
            $company_user_ids = [];
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            
            $records = $companyUserMapper->fetchAllByUserId($currentUser->id);
            foreach($records as $record)
            {
                
                if($record->status != CompanyUser::STATUS_ACCEPTED) {
                    continue;
                }
                
                $otherUsers = $companyUserMapper->fetchAllByCompanyId($record->company_id);
                foreach($otherUsers as $otherUser)
                {
                    if($currentUser->id != $otherUser->user_id && $otherUser->creator == CompanyUser::CREATOR_NO && $otherUser->status == CompanyUser::STATUS_ACCEPTED) {
                        
                        if(!in_array($otherUser->user_id, $company_user_ids)) {
                            array_push($company_user_ids, $otherUser->user_id);
                        }
                    }
                }
            }
            $company_user_ids =  $company_user_ids ? $company_user_ids : [0];
            
            /* Usuario de los grupos donde soy dueño o participo */
            
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            
            $group_member_ids = [];
            
            $records = $groupMemberMapper->fetchAllByUserId($currentUser->id);
            foreach($records as $record)
            {
                if($record->status != GroupMember::STATUS_ACCEPTED) {
                    continue;
                }
                
                $otherUsers = $groupMemberMapper->fetchAllByGroupId($record->group_id);
                foreach($otherUsers as $otherUser)
                {
                    if($currentUser->id != $otherUser->user_id && $otherUser->status == GroupMember::STATUS_ACCEPTED) {
                        
                        if(!in_array($otherUser->user_id, $group_member_ids)) {
                            array_push($group_member_ids, $otherUser->user_id);
                        }
                    }
                }
                
                
            }
            
            $group_member_ids = $group_member_ids ? $group_member_ids : [0];
            
            /* Usuarios con que comparto capsulas */
            $capsule_user_ids = [];
            $capsuleUserMapper = CompanyMicrolearningCapsuleUserMapper::getInstance($this->adapter);
            
            $company_ids = [];
            $records = $capsuleUserMapper->fetchAllActiveByUserId($currentUser->id);
            foreach($records as $record)
            {
                if(!in_array($record->company_id,$company_ids)) {
                    array_push($company_ids, $record->company_id);
                }
            }
            
            foreach($company_ids as $company_id)
            {
                $otherUsers = $capsuleUserMapper->fetchAllUserIdsForCapsulesActiveByCompanyId($company_id);
                foreach($otherUsers as $user_id)
                {
                    if($currentUser->id != $user_id ) {
                        
                        if(!in_array($user_id, $capsule_user_ids)) {
                            array_push($capsule_user_ids, $user_id);
                        }
                    }
                }
            }
            
            $capsule_user_ids = $capsule_user_ids ? $capsule_user_ids : [0];
            
 
            $other_users = array_unique(array_merge(
               
                $second_degree_connections_ids,
                $company_user_ids,
                $group_member_ids,
                $capsule_user_ids
            ));
            
            $queryMapper = QueryMapper::getInstance($this->adapter);
           
  
            $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
            $group_ids = $groupMemberMapper->fetchAllGroupIdsByUserIds( $other_users);
            $group_ids = $group_ids ? $group_ids : [0];

            
                
   
            $select = $queryMapper->getSql()->select();
            $select->columns(['id', 'uuid', 'name','image','status','privacy', 'priority' => new Expression('0') ]);
            $select->from(['g' => GroupMapper::_TABLE]); 
            $select->where->equalTo('privacy', Group::PRIVACY_IS_PUBLIC);
            $select->where->equalTo('status', Group::STATUS_ACTIVE);
            $select->where->in('g.id', $group_ids);
            $select->where->notEqualTo('g.user_id', $currentUser->id);
            $select->order('name ASC');
            
            
            
            //echo $select->getSqlString($this->adapter->platform); exit;
            
            $records = $queryMapper->fetchAll($select);
            usort($records, function ($a, $b) {
                if( $a['priority'] == $b['priority'] ) {
                    return 0; 
                } else {
                    return $a['priority'] < $b['priority'] ? 1 : -1;
                }
            });


            $items = [];
            
            foreach($records as $record)
            {
                    
                array_push($items, [
                    'id'        => $record['uuid'],
                    'name'      => trim($record['name']),
                    'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'group', 'filename' => $record['image']]),
                    'profile'   => $this->url()->fromRoute('group/view', ['id' => $record['uuid'] ]),
                    'priority'  => $record['priority'],
                    
                ]);

            }
            
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function postsAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            $items = [];
            $postMapper = PostMapper::getInstance($this->adapter);
            $posts = $postMapper->fetchAllActive();
            
            //print_r($posts);
            
            foreach($posts as $post)
            {
                $dt = \DateTime::createFromFormat('Y-m-d', $post->date);
                array_push($items, [
                    'image' => $this->url()->fromRoute('storage', ['code' => $post->uuid, 'type' => 'post', 'filename' => $post->image  ]),
                    'date' => $dt->format('d/m/Y'),
                   'title' => $post->title,
                   'link' => $this->url()->fromRoute('post', ['id' => $post->uuid]), 
                ]);
                
            }
            
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    

    
    public function searchPeopleAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            
            
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $search = trim(filter_var( $this->params()->fromQuery('search'), FILTER_SANITIZE_STRING)) ;
            if(strlen($search) >= 3) {
                
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $records  = $userMapper->fetchAllSuggest($search);
                
                $users = [];
                foreach($records as $record)
                {
                    if($currentUser->id == $record->id) {
                        continue;
                    }
                    
                    
                    array_push($users, [
                        'value' => $record->uuid,
                        'text' => trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')'
                        
                    ]);
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => $users
                ]);
                
                
                
                
            } else {
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        
                    ]
                ]);
            }
            
            
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function footerAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            
            
            $links = isset($this->navigation['footer']) ?  $this->navigation['footer'] : [];
            
       
            $data = [];
            foreach($links as $link)
            {
                $data[ $link['route'] ] = $link['label'];
            }
            
            
            return new JsonModel([
               'success' => true, 
               'data' => $data,
            ]);
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    
    /**
     * Recuperamos los grupos sugeridos
     * tiene que enviarse un petición GET a la siguiente url: /helpers/groups-suggestion/:group_id
     * retorna un json en caso de ser  positivo
     * [
     *  'success' : true,
     *  'data' : [
     *      [
     *        'id'      => 'id del grupo encriptado',
     *        'name'    => 'nombre del grupo',
     *        'image'   => 'imagen del grupo',
     *        'profile' => 'url del profile',
     *     ]
     * ]
     * En caso de ser negativo
     * [
     *  'success' : false,
     *  'data' : mensaje de error
     * ]
     * @return \Laminas\View\Model\JsonModel
     */
    public function myGroupsAction()
    {
        
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $select = $queryMapper->getSql()->select();
            $select->columns(['id', 'uuid', 'name','image','status','privacy', 'priority' => new Expression('0') ]);
            $select->from(['g' => GroupMapper::_TABLE]);
            $select->where->equalTo('status', Group::STATUS_ACTIVE);
            $select->where->equalTo('g.user_id', $currentUser->id);
            $select->order('name ASC');
            
            
            $items = [];
            
            $records = $queryMapper->fetchAll($select);
            foreach($records as $record)
            {
                    
                array_push($items, [
                    'id'        => $record['uuid'],
                    'name'      => trim($record['name']),
                    'image'     => $this->url()->fromRoute('storage', ['code' => $record['uuid'], 'type' => 'group', 'filename' => $record['image']]),
                    'profile'   => $this->url()->fromRoute('group/view', ['id' => $record['uuid'] ]),
                    'priority'  => $record['priority'],
                        
                ]);
                    
            }
                
            return new JsonModel([
                'success' => true,
                'data' => $items
            ]);
                
                
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
}