Proyectos de Subversion LeadersLinked - Antes de SPA

<?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->equalTo('network_id', $currentUser->network_id);

            $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()) {

            $currentUserPlugin = $this->plugin('currentUserPlugin');

            $currentUser = $currentUserPlugin->getUser();

            $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('network_id', $currentUser->network_id);

                $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()) {

            $currentUserPlugin = $this->plugin('currentUserPlugin');

            $currentUser = $currentUserPlugin->getUser();

            $company_uuid  = $this->params()->fromRoute('company_id');

            $companyMapper = CompanyMapper::getInstance($this->adapter);

            $company = $companyMapper->fetchOneByUuidAndNetworkId($company_uuid, $currentUser->network_id);

            $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->equalTo('network_id', $currentUser->network_id);

                    $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()) {

            $currentUserPlugin = $this->plugin('currentUserPlugin');

            $currentUser = $currentUserPlugin->getUser();

            $company_uuid = $this->params()->fromRoute('company_id');

            $companyMapper = CompanyMapper::getInstance($this->adapter);

            $company = $companyMapper->fetchOneByUuidAndNetworkId($company_uuid, $currentUser->network_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->equalTo('network_id', $currentUser->network_id);

                $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->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);

            $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('u.network_id',  $currentUser->network_id);

                $select->where->equalTo('g.network_id', $currentUser->network_id);

                $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->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);

        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->fetchAllSuggestForInvitationByGroupIdAndNetworkIdAndSearch($group->id, $currentUser->network_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->fetchOneByUuidAndNetworkId($uuid, $currentUser->network_id);

            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->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_RECEIVE_INVITATION_GROUP, $currentUser->network_id);

                    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->fetchOneByUuidAndNetworkId($group_uuid, $currentUser->network_id);

            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->fetchOneByUuidAndNetworkId($user_uuid, $currentUser->network_id);

            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 {