Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

Rev 3639 | Rev 6849 | 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\Authentication\AuthenticationService;
use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Model\UserExperience;
use LeadersLinked\Mapper\UserExperienceMapper;
use Laminas\Db\Sql\Select;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Model\User;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Mapper\CompanySizeMapper;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Mapper\GroupMemberMapper;
use LeadersLinked\Mapper\IndustryMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Mapper\UserSkillMapper;
use LeadersLinked\Mapper\SkillMapper;
use LeadersLinked\Model\Job;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Mapper\UserProfileMapper;
use LeadersLinked\Model\UserProfile;
use Laminas\Db\Sql\Expression;
use LeadersLinked\Mapper\GroupTypeMapper;
use LeadersLinked\Mapper\JobMapper;
use LeadersLinked\Mapper\ProfileVisitMapper;
use LeadersLinked\Mapper\CompanyLocationMapper;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\JobApplicationMapper;
use LeadersLinked\Model\UserType;
use LeadersLinked\Mapper\UserBlockedMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\Group;
use LeadersLinked\Model\Network;

class SearchController extends AbstractActionController
{
    /**
     *
     * @var AdapterInterface
     */
    private $adapter;
    
    
    /**
     *
     * @var AbstractAdapter
     */
    private $cache;
    
    /**
     *
     * @var  LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
   
 
    /**
     *
     * @param AdapterInterface $adapter
     * @param AbstractAdapter $cache
     * @param LoggerInterface $logger
     * @param array $config
     */
    public function __construct($adapter, $cache , $logger, $config)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
    }
    
    public function indexAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork= $currentNetworkPlugin->getNetwork();
        
        
        $page       = (int) filter_var($this->params()->fromQuery('page'), FILTER_SANITIZE_NUMBER_INT);
        $keyword    = filter_var($this->params()->fromQuery('keyword'), FILTER_SANITIZE_STRING);
        $entity     = $this->params()->fromRoute('entity');
        $country    = filter_var($this->params()->fromQuery('country'), FILTER_SANITIZE_STRING);
        $state      = filter_var($this->params()->fromQuery('state'), FILTER_SANITIZE_STRING);
        $city1      = filter_var($this->params()->fromQuery('city1'), FILTER_SANITIZE_STRING);
        $city2      = filter_var($this->params()->fromQuery('city2'), FILTER_SANITIZE_STRING);
        
        
       // echo 'keyword = ' . $keyword .PHP_EOL;
        //echo 'entity = ' . $entity . PHP_EOL;
        
        $request = $this->getRequest();
        if($request->isGet()) {
            
            
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                    
                }
            }
            

            if($isJson) {

                
                $userBlockedMapper = UserBlockedMapper::getInstance($this->adapter);
                $user_blocked_ids = $userBlockedMapper->fetchAllBlockedReturnIds($currentUser->id);
                
                switch($entity)
                {
                    case 'user' : 
                        $grade1     = intval($this->params()->fromQuery('connection_level_1'), 10);
                        $grade2     = intval($this->params()->fromQuery('connection_level_2'), 10);
                        
                        
                        
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        
                        $select = $queryMapper->getSql()->select();
                        $select->columns(['id', 'user_uuid' => 'uuid', 'first_name','last_name','image']);
                        $select->from(['u' => UserMapper::_TABLE]);
                        $select->join(['ue' => UserExperienceMapper::_TABLE], 'u.id = ue.user_id',[ 'industry_id'] , Select::JOIN_LEFT);
                        $select->join(['up' => UserProfileMapper::_TABLE], "u.id = up.user_id ", ['user_profile_uuid' => 'uuid', 'user_profile_id' => 'id', 'description'] );
                        $select->join(['l' => LocationMapper::_TABLE], "u.location_id = l.id" ,['country', 'state', 'city1', 'city2'], Select::JOIN_LEFT);
                        $select->where->equalTo('u.network_id', $currentUser->network_id);
                        $select->where->equalTo('up.public', UserProfile::PUBLIC_YES);
  
                        
                        if($country) {
                            $select->where->equalTo('country', $country);
                        }
                        if($state) {
                            $select->where->equalTo('state', $state);
                        }
                        if($city1) {
                            $select->where->equalTo('city1', $city1);
                        }
                        if($city2) {
                            $select->where->equalTo('city2', $city2);
                        }
                        
                        if($grade1 && $grade2) {
                            $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                            $first_grade    = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
                            if(!$first_grade) {
                                array_push($first_grade, 0);
                            }
                            
                            $second_grade   = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
                            if(!$second_grade) {
                                array_push($second_grade, 0);
                            }
                            
                            $select->where->nest->in('u.id', $first_grade)->or->in('u.id',$second_grade)->unnest();
                        } else {
                            if($grade1) {
                                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                                $first_grade    = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
                                if(!$first_grade) {
                                    array_push($first_grade, 0);
                                }
                                
                                $select->where->in('u.id', $first_grade);
                                
                            } else if($grade2) {
                                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                                $second_grade   = $connectionMapper->fetchAllSecondDegreeConnectionsForUserIdReturnIds($currentUser->id);
                                if(!$second_grade) {
                                    array_push($second_grade, 0);
                                }
                                
                                $select->where->in('u.id',$second_grade);
                                
                            }
                        }
                        if($user_blocked_ids) {
                            $select->where->notIn('u.id', $user_blocked_ids);
                        }
                        
                        $select->where->notEqualTo('u.id', $currentUser->id);
                        /*
                        $industry_ids = [];
                        
                        $userExperienceMapper = UserExperienceMapper::getInstance($this->adapter);
                        $experiences = $userExperienceMapper->fetchAllByUserId($currentUser->id);
                        foreach($experiences as $experience)
                        {
                            if($experience->is_current == UserExperience::IS_CURRENT_YES) {
                                if(!in_array($experience->industry_id, $industry_ids)) {
                                    array_push($industry_ids, $experience->industry_id);
                                }
                            }
                        }
                        
                        if($industry_ids) {
                            $select->where->in('industry_id', $industry_ids);
                        }
                        */
                        $select->where->in('u.usertype_id', [UserType::USER, UserType::ADMIN]);
                        $select->where->equalTo('u.status', User::STATUS_ACTIVE);
                        $select->where->equalTo('u.show_in_search', User::SHOW_IN_SEARCH_YES);
                        
                        if($keyword) {
                            $select->where->NEST->like('u.first_name', '%' . $keyword . '%')->or->like('u.last_name', '%' . $keyword . '%')->UNNEST;
                        }
                        $select->group('u.id');
                        
                        $select->order(new Expression('rand()'));
                        
                        //echo $select->getSqlString($this->adapter->platform); exit;
                        break;
                        
                    case 'company' : 
                        
                        $companySizeMapper = CompanySizeMapper::getInstance($this->adapter);
                        $companySizes = $companySizeMapper->fetchAll();
                        
                        $company_sizes = [];
                        
                        foreach($companySizes as $companySize) 
                        {
                            
                            $company_size_id = intval($this->params()->fromQuery('company_size_id'. $companySize->uuid), 10);
                            if($company_size_id) {
                                array_push($company_sizes, $companySize->id);
                            }
                        }
                        
                        $industryMapper = IndustryMapper::getInstance($this->adapter);
                        $industries = $industryMapper->fetchAllActive();
                        
                        $industry_ids = [];
                        foreach($industries as $industry)
                        {
                            $industry_id = intval($this->params()->fromQuery('industry_id'. $industry->uuid), 10);
                            if($industry_id) {
                                if(!in_array($industry_id, $industry_ids)) {
                                    array_push($industry_ids, $industry->id);
                                }
                            }
                        }
                        
                        
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        $select = $queryMapper->getSql()->select();
                        $select->columns(['id','company_uuid' => 'uuid', 'name','image', 'description', 'industry_id', 'company_size_id']);
                        $select->from(['c' => CompanyMapper::_TABLE]);
                        $select->join(['cl' => CompanyLocationMapper::_TABLE], 'c.id = cl.company_id', ['location_id', 'is_main'], Select::JOIN_LEFT);
                        $select->join(['l' => LocationMapper::_TABLE], 'cl.location_id = l.id' ,['formatted_address', 'country', 'state', 'city1', 'city2'], Select::JOIN_LEFT);
                        $select->join(['cu' => CompanyUserMapper::_TABLE], 'c.id = cu.company_id', ['user_id', 'owner']);
                        //$select->where->equalTo('cl.is_main', CompanyLocation::IS_MAIN_YES);
                        $select->where->equalTo('c.network_id', $currentUser->network_id);
                        $select->where->equalTo('cu.owner', CompanyUser::OWNER_YES);
                        $select->where->equalTo('c.status', Company::STATUS_ACTIVE);
                        
                        
                        
                        if($user_blocked_ids) {
                            $select->where->notIn('cu.user_id', $user_blocked_ids);
                        }
                        
                        if($industry_ids) {
                            $select->where->in('c.industry_id', $industry_ids);
                        }
                       
                        
                        if($company_sizes) {
                            $select->where->in('c.company_size_id',$company_sizes);
                        }
                        
                        
                        if($country) {
                            $select->where->equalTo('l.country', $country);
                        }
                        if($state) {
                            $select->where->equalTo('l.state', $state);
                        }
                        if($city1) {
                            $select->where->equalTo('l.city1', $city1);
                        }
                        if($city2) {
                            $select->where->equalTo('l.city2', $city2);
                        }

                        if($keyword) {
                            $select->where->like('c.name', '%' . $keyword . '%');
                        }
                        
                        $select->group('c.id');
                        
  
                        $select->order(new Expression('rand()'));
                        
                        //echo $select->getSqlString($this->adapter->platform); exit;
                        break;
                        
                    case 'group' : 
                        
                        $groupTypeMapper = GroupTypeMapper::getInstance($this->adapter);
                        $groupTypes = $groupTypeMapper->fetchAllActive();
                        

                        $group_type_ids = [];
                        foreach($groupTypes as $groupType)
                        {

                            $group_type_id = intval($this->params()->fromQuery('group_type_id'. $groupType->uuid), 10);
                            if($group_type_id) {
                                if(!in_array($group_type_id, $group_type_ids)) {
                                    array_push($group_type_ids, $groupType->id);
                                }
                            }
                        }
                        
                        $industryMapper = IndustryMapper::getInstance($this->adapter);
                        $industries = $industryMapper->fetchAllActive();
                        
                        $industry_ids = [];
                        foreach($industries as $industry)
                        {
                            $industry_id = intval($this->params()->fromQuery('industry_id'. $industry->uuid), 10);
                            if($industry_id) {
                                if(!in_array($industry_id, $industry_ids)) {
                                    array_push($industry_ids, $industry->id);
                                }
                            }
                        }
                        
                        
         
                        
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        $select = $queryMapper->getSql()->select();
                        $select->columns(['id', 'group_uuid' => 'uuid',  'name', 'description','image','type_id', 'industry_id', 'user_id' ]);
                        $select->from(['g' => GroupMapper::_TABLE]);
                        $select->where->equalTo('g.network_id', $currentUser->network_id);
                        
                        if($group_type_ids) {
                            $select->where->in('type_id', $group_type_ids);
                        }
                        
                        if($industry_ids) {
                            $select->where->in('industry_id', $industry_ids);
                        }
                        
                        if($keyword) {
                            $select->where->like('name', '%' . $keyword . '%');
                        }
                        
                        if($user_blocked_ids) {
                            $select->where->notIn('user_id', $user_blocked_ids);
                        }
                        $select->where->equalTo('status', Group::STATUS_ACTIVE);
                        $select->where->equalTo('privacy', Group::PRIVACY_IS_PUBLIC);
                        
                        $select->group('g.id');
                        $select->order(new Expression('rand()'));
                        
                        //echo $select->getSqlString($this->adapter->platform); exit;
                        
                        break;
                        
                    case 'job' :
                        $jobFullTime    = intval($this->params()->fromQuery('employment_type_id' . Job::EMPLOYMENT_TYPE_FULL_TIME), 10);
                        $jobPartTime    = intval($this->params()->fromQuery('employment_type_id' . Job::EMPLOYMENT_TYPE_PART_TIME), 10);
                        $jobContract    = intval($this->params()->fromQuery('employment_type_id' . Job::EMPLOYMENT_TYPE_CONTRACT), 10);
                        $jobTemporary   = intval($this->params()->fromQuery('employment_type_id' . Job::EMPLOYMENT_TYPE_TEMPORARY ), 10);
                        
                        $employment_types = [];
                        if($jobFullTime) {
                            array_push($employment_types, Job::EMPLOYMENT_TYPE_FULL_TIME);
                        }
                        if($jobPartTime) {
                            array_push($employment_types, Job::EMPLOYMENT_TYPE_PART_TIME);
                        }
                        if($jobContract) {
                            array_push($employment_types, Job::EMPLOYMENT_TYPE_CONTRACT);
                        }
                        if($jobTemporary) {
                            array_push($employment_types, Job::EMPLOYMENT_TYPE_TEMPORARY);
                        }
                        
                        $companySizeMapper = CompanySizeMapper::getInstance($this->adapter);
                        $companySizes = $companySizeMapper->fetchAll();
                        
                        $company_sizes = [];
                        
                        foreach($companySizes as $companySize)
                        {
                            
                            $company_size_id = intval($this->params()->fromQuery('company_size_id'. $companySize->uuid), 10);
                            if($company_size_id) {
                                array_push($company_sizes, $companySize->id);
                            }
                        }
                        
                        $industryMapper = IndustryMapper::getInstance($this->adapter);
                        $industries = $industryMapper->fetchAllActive();
                        
                        $industry_ids = [];
                        foreach($industries as $industry)
                        {
                            $industry_id = intval($this->params()->fromQuery('industry_id'. $industry->uuid), 10);
                            if($industry_id) {
                                if(!in_array($industry_id, $industry_ids)) {
                                    array_push($industry_ids, $industry->id);
                                }
                            }
                        }
                        
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        $select = $queryMapper->getSql()->select();
                        $select->columns(['id', 'job_uuid' => 'uuid', 'company_id','title','description','employment_type','location_id','last_date_of_application','experience_visible','experience_min','experience_max']);
                        $select->from(['j' => JobMapper::_TABLE]);
                        $select->join(['c' => CompanyMapper::_TABLE] , 'c.id = j.company_id', ['company_uuid' => 'uuid', 'company_name' => 'name', 'image', 'industry_id', 'company_size_id']);
                        $select->join(['l' => LocationMapper::_TABLE], 'j.location_id = l.id' ,['formatted_address', 'country', 'state', 'city1', 'city2'] );
                        $select->join(['cu' => CompanyUserMapper::_TABLE], 'c.id = cu.company_id', ['user_id', 'owner']);
                        $select->where->equalTo('j.network_id', $currentUser->network_id);
                        $select->where->equalTo('cu.owner', CompanyUser::OWNER_YES);
                        $select->where->equalTo('c.status', Company::STATUS_ACTIVE);
                        
                        if($user_blocked_ids) {
                            $select->where->notIn('cu.user_id', $user_blocked_ids);
                        }
                        
                        if($employment_types) {
                            $select->where->in('employment_type', $employment_types);
                        }
                        
                        if($industry_ids) {
                            $select->where->in('industry_id', $industry_ids);
                        }
                        
                        if($company_sizes) {
                            $select->where->in('c.company_size_id',$company_sizes);
                        }
                        
                        if($country) {
                            $select->where->equalTo('country', $country);
                        }
                        if($state) {
                            $select->where->equalTo('state', $state);
                        }
                        if($city1) {
                            $select->where->equalTo('city1', $city1);
                        }
                        if($city2) {
                            $select->where->equalTo('city2', $city2);
                        }
                        
                        if($keyword) {
                            $select->where->like('title', '%' . $keyword . '%');
                        }
                        
                        $select->where->equalTo('c.status', Company::STATUS_ACTIVE);
                        $select->where->equalTo('j.status', Job::STATUS_ACTIVE);
                        $select->where->greaterThanOrEqualTo('last_date_of_application', new Expression('DATE(NOW())'));
                        
                        $select->group('j.id');
                        $select->order(new Expression('rand()'));

                        break;
                }
                
                //echo $select->getSqlString($this->adapter->platform); exit;
                
                $dbSelect = new DbSelect($select, $this->adapter);
                $paginator = new Paginator($dbSelect);
                $paginator->setCurrentPageNumber($page ? $page : 1);
                $paginator->setItemCountPerPage(10);
                
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                $industryMapper = IndustryMapper::getInstance($this->adapter);
                $jobApplicationMapper = JobApplicationMapper::getInstance($this->adapter);
                $groupTypeMapper = GroupTypeMapper::getInstance($this->adapter);
                $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
                $profileVisitMapper = ProfileVisitMapper::getInstance($this->adapter);
                $userSkillMapper = UserSkillMapper::getInstance($this->adapter);
                
                $months = [
                    1 => 'LABEL_MONTH_JANUARY',
                    2 => 'LABEL_MONTH_FEBRUARY',
                    3 => 'LABEL_MONTH_MARCH',
                    4 => 'LABEL_MONTH_APRIL',
                    5 => 'LABEL_MONTH_MAY',
                    6 => 'LABEL_MONTH_JUNE',
                    7 => 'LABEL_MONTH_JULY',
                    8 => 'LABEL_MONTH_AUGUST',
                    9 => 'LABEL_MONTH_SEPTEMBER',
                    10 => 'LABEL_MONTH_OCTOBER',
                    11 => 'LABEL_MONTH_NOVEMBER',
                    12 => 'LABEL_MONTH_DECEMBER',
                ];
                
                $employmentTypes = [
                    Job::EMPLOYMENT_TYPE_FULL_TIME => 'LABEL_EMPLOYMENT_TYPE_FULL_TIME',
                    Job::EMPLOYMENT_TYPE_PART_TIME => 'LABEL_EMPLOYMENT_TYPE_PART_TIME',
                    Job::EMPLOYMENT_TYPE_CONTRACT => 'LABEL_EMPLOYMENT_TYPE_CONTRACT',
                    Job::EMPLOYMENT_TYPE_TEMPORARY => 'LABEL_EMPLOYMENT_TYPE_TEMPORARY'
                ];
                
                
                
                
                $items = [];
                $records = $paginator->getCurrentItems();
                foreach($records as $record)
                {
                    switch($entity)
                    {
                        case 'user' : 
                            
                            $skills = [];
                            if($record['user_profile_id']) {
                                $skillMapper = SkillMapper::getInstance($this->adapter);
                                
                                $userSkillMapper = UserSkillMapper::getInstance($this->adapter);
                                $userSkillRecords = $userSkillMapper->fetchAllByUserProfileId($record['user_profile_id']);
                             
                                
                                foreach($userSkillRecords as $userSkillRecord)
                                {
                                    $skill = $skillMapper->fetchOne($userSkillRecord->skill_id);
                                    $skills[$skill->uuid] = $skill->name;
                                }
                                
                            }
                            
                            $industry       = $record['industry_id'] ? $industryMapper->fetchOne($record['industry_id']) : '';
                            $views          = $profileVisitMapper->getTotalByVisitedId($record['id']);
                            
            
                            $item = [
                                'id' => $record['user_uuid'],
                                'id_encripted' => $record['user_uuid'],
                                'name' => $record['first_name'] . ' ' . $record['last_name'], 
                                'description' => $record['description'],
                                'image' => $this->url()->fromRoute('storage',['type' => 'user', 'code' =>  $record['user_uuid'], 'filename' => $record['image']]),
                                'url' => $this->url()->fromRoute('profile/view',['id' => $record['user_uuid'] ]),
                                'industry' => $industry? $industry->name : '',
                                'skills' => $skills ? $skills : [],
                                
                                'views' => $views
                            ];
                            
                            if($currentNetwork->relationship_user_mode == Network::RELATIONSHIP_USER_MODE_USER_2_USER)  {
                                $common_connection = count($connectionMapper->fetchAllCommonConnectionsUserIdByUser1ReturnIds($currentUser->id, $record['id']));
                                
                                $item['common_connection'] = $common_connection;
                                $item['view_common_connection'] = 1;
                            } else {
                                $item['common_connection'] = 0;
                                $item['view_common_connection'] = 0;
                            }
                            
                            
                            array_push($items, $item);                                
                            
                            break;
                            
                        case 'company' :
                            $industry       = $industryMapper->fetchOne($record['industry_id']);
                            $companySize    = $companySizeMapper->fetchOne($record['company_size_id']);
                            $followers      = $companyFollowerMapper->getCountFollowers($record['id']);
                            
                            $item = [
                                'id' => $record['id'],
                                'id_encripted' => $record['company_uuid'],
                                'name' => $record['name'],
                                'description' => $record['description'],
                                'image' => $this->url()->fromRoute('storage',['type' => 'company', 'code' => $record['company_uuid'] , 'filename' => $record['image']]),
                                'url' => $this->url()->fromRoute('company/view',['id' => $record['company_uuid'] ]),
                                'industry' => $industry->name,
                                'company_size' => $companySize->name,
                                'location' => $record['formatted_address'],
                                'followers' => $followers,
                            ];
                            array_push($items, $item);
                            
                            break;
                            
                        case 'job' :


                            $employment_type = $employmentTypes[ $record['employment_type'] ];
                            
                            
                            $industry           = $industryMapper->fetchOne($record['industry_id']);
                            $companySize        = $companySizeMapper->fetchOne($record['company_size_id']);
                            $total_applications = $jobApplicationMapper->fetchTotalApplicationsByJobId($record['id']);
                            

                            
                            $followers      = $companyFollowerMapper->getCountFollowers($record['id']);
                            
                            if($record['experience_visible'] == Job::EXPERIENCE_VISIBLE_YES) {
                                $experience = $record['experience_min'].'-'.$record['experience_max'] . ' LABEL_YEARS';
                            } else {
                                $experience = '';
                            }
                            
                            $dt = \DateTime::createFromFormat('Y-m-d', $record['last_date_of_application']);
                            

                            $dt = \DateTime::createFromFormat('Y-m-d', $record['last_date_of_application']);
                            $last_date_of_application = $dt->format('d') . ' de ' . $months[$dt->format('n')] . ' de ' . $dt->format('Y');
                            
                            $item = [
                                'id' => $record['id'],
                                'id_encripted' => $record['job_uuid'],
                                'title' => $record['title'],
                                'description' => $record['description'],
                                'image' => $this->url()->fromRoute('storage',['type' => 'company', 'code' => $record['company_uuid'], 'filename' => $record['image']]),
                                'url' => $this->url()->fromRoute('job/view',['id' => $record['job_uuid']]),
                                'company_name' => $record['company_name'],
                                'company_url' => $this->url()->fromRoute('company/view',['id' => $record['company_uuid'] ]),
                                'industry' => $industry->name,
                                'company_size' => $companySize->name,
                                'employment_type' => $employment_type,
                                'location' => $record['formatted_address'],
                                'total_applications' => $total_applications,
                                'experience' => $experience,
                                'last_date' => $last_date_of_application
                            ];
                            array_push($items, $item);
                            
                            break;
                            
                        case 'group' :
                            
                            
                            $groupType      = $groupTypeMapper->fetchOne($record['type_id']);
                            $industry       = $industryMapper->fetchOne($record['industry_id']);
                            
                            $total_members  = $groupMemberMapper->fetchTotalAcceptedByGroupId($record['id']);
                            
                            $members      = $groupMemberMapper->fetchAllAcceptedUserIdsByGroupId($record['id']);
                            $connections  = $connectionMapper->fetchAllConnectionsByUserReturnIds($currentUser->id);
                            $common_connection = count(array_intersect($members, $connections));
                            
                            $item = [
                                'id' => $record['id'],
                                'id_encripted' => $record['group_uuid'],
                                'name' => $record['name'],
                                'description' => $record['description'],
                                'image' => $this->url()->fromRoute('storage',['type' => 'group', 'code' => $record['group_uuid'], 'filename' => $record['image']]),
                                'url' => $this->url()->fromRoute('group/view',['id' => $record['group_uuid']]),
                                'industry' => $industry->name,
                                'group_type' => $groupType->name,
                                'total_members' => $total_members,
                                'common_connection' => $common_connection,
                                
                            ];
                            array_push($items, $item);  

                            break;
                    }
                }
                
                $response = [
                    'success' => true,
                    
                    'data' => [
                        'entity' => $entity,
                        'total' => [
                            'count' => $paginator->getTotalItemCount(),
                            'pages' => $paginator->getPages()->pageCount,
                        ],
                        'current' => [
                            'items'    => $items,
                            'page'     => $paginator->getCurrentPageNumber(),
                            'count'    => $paginator->getCurrentItemCount(),
                        ]
                    ]
                ];
                
                
                
                return new JsonModel($response);
            } else {
                
                $sandbox = $this->config['leaderslinked.runmode.sandbox'];
                if($sandbox) {
                    $google_map_key  = $this->config['leaderslinked.google_map.sandbox_api_key'];
                } else {
                    $google_map_key  = $this->config['leaderslinked.google_map.production_api_key'];
                }
                
                $groupTypes = [];
                $groupTypeMapper = GroupTypeMapper::getInstance($this->adapter);
                $records = $groupTypeMapper->fetchAllActive();
                foreach($records as $record) 
                {
                    $groupTypes[$record->uuid] = $record->name;
                }
                
                
                $industries = [];
                $industryMapper = IndustryMapper::getInstance($this->adapter);
                $records = $industryMapper->fetchAllActive();
                foreach($records as $record)
                {
                    $industries[$record->uuid] = $record->name;
                }
                
                $companySizes = [];
                $companySizeMapper = CompanySizeMapper::getInstance($this->adapter);
                $records = $companySizeMapper->fetchAllActive();
                foreach($records as $record)
                {
                    $companySizes[$record->uuid] = $record->name . ' ('.$record->minimum_no_of_employee . '-' . $record->maximum_no_of_employee .')';
                }
                
                
                $employmentTypes = [
                    Job::EMPLOYMENT_TYPE_FULL_TIME => 'LABEL_EMPLOYMENT_TYPE_FULL_TIME',
                    Job::EMPLOYMENT_TYPE_PART_TIME => 'LABEL_EMPLOYMENT_TYPE_PART_TIME',
                    Job::EMPLOYMENT_TYPE_CONTRACT => 'LABEL_EMPLOYMENT_TYPE_CONTRACT',
                    Job::EMPLOYMENT_TYPE_TEMPORARY => 'LABEL_EMPLOYMENT_TYPE_TEMPORARY'
                ];
                
                $connectionLeves = [
                    1 => 'LABEL_FIRST_GRADE',
                    2 => 'LABEL_SECOND_GRADE' 
                ];

                $viewModel = new ViewModel();
                $this->layout()->setTemplate('layout/layout.phtml');
                $viewModel->setTemplate('leaders-linked/search/index.phtml');
                $viewModel->setVariables([
                    'groupTypes' => $groupTypes,
                    'industries' => $industries,
                    'companySizes' => $companySizes,
                    'employeeTypes' => $employmentTypes,
                    'connectionLeves' =>  $connectionLeves,
                    'keyword' => $keyword,
                    'google_map_key' => $google_map_key,
                    
                ]);
                
                return $viewModel;
            }
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
        
        
       
        
    }
    
    
}