Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 3338 | Autoría | Ultima modificación | Ver Log | 

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;
use LeadersLinked\Library\InterviewPDF;
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Form\RecruitmentSelectionInterviewFormForm;
use LeadersLinked\Form\JobDescriptionForm;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\CompetencyTypeMapper;
use LeadersLinked\Model\JobDescription;
use LeadersLinked\Mapper\CompetencyMapper;
use LeadersLinked\Library\JobPdf;
use LeadersLinked\Mapper\JobDescriptionCompetencyMapper;
use LeadersLinked\Mapper\JobDescriptionSubordinateMapper;
use LeadersLinked\Model\JobDescriptionCompetency;
use LeadersLinked\Model\JobDescriptionBehaviorCompetency;
use LeadersLinked\Mapper\JobDescriptionBehaviorCompetencyMapper;
use LeadersLinked\Model\JobDescriptionSubordinate;
use LeadersLinked\Mapper\BehaviorCompetencyMapper;
use LeadersLinked\Model\BehaviorCompetency;
use LeadersLinked\Mapper\BehaviorMapper;
use LeadersLinked\Model\Behavior;
use LeadersLinked\Model\Company;
use LeadersLinked\Mapper\RecruitmentSelectionInterviewMapper;
use LeadersLinked\Model\RecruitmentSelectionInterview;
use LeadersLinked\Mapper\RecruitmentSelectionVacancyMapper;
use LeadersLinked\Model\RecruitmentSelectionVacancy;
use LeadersLinked\Mapper\RecruitmentSelectionCandidateMapper;
use LeadersLinked\Model\RecruitmentSelectionCandidate;
use LeadersLinked\Mapper\JobDescriptionMapper;
use Laminas\View\Model\ViewModel;
use LeadersLinked\Form\RecruitmentSelectionCandidateFormForm;
use Laminas\Hydrator\ArraySerializableHydrator;
use Laminas\Db\ResultSet\HydratingResultSet;
use LeadersLinked\Mapper\QueryMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;

class RecruitmentSelectionInterviewFormController 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();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        if($request->isGet())
        {
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                }
            }
            
            if ($isJson) {
                $vacancy_uuid = filter_var($this->params()->fromQuery('vacancy_uuid'), FILTER_SANITIZE_STRING);
                
                $search = $this->params()->fromQuery('search', []);
                $search = empty($search['value']) ? '' : filter_var($search['value'], FILTER_SANITIZE_STRING);

                $page = intval($this->params()->fromQuery('start', 1), 10);
                $records_x_page = intval($this->params()->fromQuery('length', 10), 10);
                $order = $this->params()->fromQuery('order', []);
                $order_field = empty($order[0]['column']) ? 99 : intval($order[0]['column'], 10);
                $order_direction = empty($order[0]['dir']) ? 'ASC' : strtoupper(filter_var($order[0]['dir'], FILTER_SANITIZE_STRING));

                $fields = ['uuid', 'first_name', 'last_name', 'email'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'first_name';

                if (!in_array($order_direction, ['ASC', 'DESC'])) {
                    $order_direction = 'ASC';
                }

                
                $data = [
                    'items' => [] ,
                    'total' => 0,
                ];
                
                if(!$vacancy_uuid) {
                    return new JsonModel([
                        'success' => true,
                        'data' => $data
                    ]);
                }
                
                $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
                $vacancy = $vacancyMapper->fetchOneByUuid($vacancy_uuid);
                
                if(! $vacancy) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_VACANCY_NOT_FOUND'
                    ]);
                }
                
                if($vacancy->company_id != $currentCompany->id) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);
                }
                
                $candidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
                $candidates = $candidateMapper->fetchAllBySelectionId($vacancy->id);

               // $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
               // $paginator = $recruitmentSelectionInterviewMapper->fetchAllByCandidateId($candidates->id, $search, $page, $records_x_page, $order_field, $order_direction);


                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $jobDescription = $jobDescriptionMapper->fetchOne($vacancy->job_description_id);
 
                $interviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
                $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
                $paginator = $recruitmentSelectionInterviewMapper->fetchAllByVacancyId($vacancy->id, $search, $page, $records_x_page, $order_field, $order_direction);


                foreach($candidates as $candidate){
                    
                    $interview = $interviewMapper->fetchOneByCandidateIdAndVacancyId($candidate->id, $vacancy->id);

                    if($interview){
                        $candidate->add_url = '';
                        $candidate->edit_url = $this->url()->fromRoute('recruitment-and-selection/interview/form/edit', ['interview_uuid' => $interview->uuid]);
                        $candidate->delete_url = $this->url()->fromRoute('recruitment-and-selection/interview/form/delete', ['interview_uuid' => $interview->uuid]);
                        $candidate->report_url = $this->url()->fromRoute('recruitment-and-selection/interview/report', ['interview_uuid' => $interview->uuid]);
                    } else {
                        $candidate->add_url = $this->url()->fromRoute('recruitment-and-selection/interview/form/add', ['candidate_uuid' => $candidate->uuid]);
                        $candidate->edit_url = '';
                        $candidate->delete_url = '';
                    }
                }
                
                $interview = $interviewMapper->fetchAllByVacancyId($vacancy->id);

                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'vacancy' => $vacancy,
                        'candidates' => $candidates,
                        'job_description' =>[ 
                            'uuid' => $jobDescription->uuid,
                            'name' => $jobDescription->name,
                            'functions' => $jobDescription->functions, 
                            'objectives' => $jobDescription->objectives,
                            'competencies' => []
                        ],
                        'interview' => $interview,
                        'paginator' => $paginator,
                    ],
                ]);

                $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
                $jobDescriptionCompetencies = $jobDescriptionCompetencyMapper->fetchByJobDescriptionId($jobDescription->id);
               
                $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
                $competencyMapper = CompetencyMapper::getInstance($this->adapter);
                $behaviorCompetencyMapper = BehaviorCompetencyMapper::getInstance($this->adapter);
                $behaviorMapper = BehaviorMapper::getInstance($this->adapter);

                foreach ($jobDescriptionCompetencies as $jobDescriptionCompetency) {
                    $competency = $competencyMapper->fetchOne($jobDescriptionCompetency->competency_id);
                    $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
                    $behaviorCompetencies = $behaviorCompetencyMapper->fetchByCompetencyId($competency->id);
    
                    $behaviors = [];
    
                    foreach ($behaviorCompetencies as $behaviorCompetency) {
                        $behavior = $behaviorMapper->fetchOne($behaviorCompetency->behavior_id);
                        
                        $behaviors []= [
                            'uuid' => $behavior->uuid,
                            'description' => $behavior->description,
                            'points' => 0,
                            'comment' => '',
                            'competency_uuid' => $competency->uuid,
                        ];
                    }
    
                    array_push($data['job_description']['competencies'], [
                        'competency_uuid' => $competency->uuid,
                        'competency_name' => $competency->name,
                        'competency_type_uuid' => $competencyType->uuid,
                        'competency_type_name' => $competencyType->name,
                        'behaviors' => $behaviors,
                    ]);
                }
            } else {
                $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
                $vacancies = $vacancyMapper->fetchAllByCompanyId($currentCompany->id);

                $form = new RecruitmentSelectionInterviewFormForm($this->adapter, $currentCompany ? $currentCompany->id : null);
                
                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/recruitment-and-selection-interview/index.phtml');
                $viewModel->setVariables([
                    'form'      => $form,
                    'vacancies' => $vacancies
                ]);
                
                return $viewModel ;
            }
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }

    public function addAction() {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

   
        $candidate_uuid = $this->params()->fromRoute('candidate_uuid');

        if ($request->isGet()) {

            
            $candidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
            $candidate = $candidateMapper->fetchOneByUuid($candidate_uuid);
            
            
            
            
            $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
            $vacancy = $vacancyMapper->fetchOne($candidate->vacancy_id);
            
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            $jobDescription = $jobDescriptionMapper->fetchOne($vacancy->job_description_id);
            
            $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
            $jobDescriptionCompetencies = $jobDescriptionCompetencyMapper->fetchByJobDescriptionId($jobDescription->id);
            
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
            $behaviorCompetencyMapper = BehaviorCompetencyMapper::getInstance($this->adapter);
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
            
            
            
            $data = [
                'candidate' => [
                    'uuid' => $candidate->uuid,
                    'first_name' => $candidate->first_name,
                    'last_name' => $candidate->last_name,
                    'email' => $candidate->email
                ], 
                'job_description' => [
                
                    'uuid' => $jobDescription->uuid,
                    'name' => $jobDescription->name,
                    'functions' => $jobDescription->functions, 
                    'objectives' => $jobDescription->objectives,
                    'competencies' => []
                ], 
                'interview' => [
                    'type' => RecruitmentSelectionInterview::STATUS_HUMAN_RESOURCE,
                    'status' => RecruitmentSelectionInterview::STATUS_ACCEPTED,
                    'points' => 0,
                    'comment' => '',
                ]
            ];

            foreach ($jobDescriptionCompetencies as $jobDescriptionCompetency) {
                $competency = $competencyMapper->fetchOne($jobDescriptionCompetency->competency_id);
                $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
                $behaviorCompetencies = $behaviorCompetencyMapper->fetchByCompetencyId($competency->id);

                $behaviors = [];

                foreach ($behaviorCompetencies as $behaviorCompetency) {
                    $behavior = $behaviorMapper->fetchOne($behaviorCompetency->behavior_id);
                    
                    $behaviors []= [
                        'uuid' => $behavior->uuid,
                        'description' => $behavior->description,
                        'points' => 0,
                        'comment' => '',
                        'competency_uuid' => $competency->uuid,
                    ];
                }

                array_push($data['job_description']['competencies'], [
                    'competency_uuid' => $competency->uuid,
                    'competency_name' => $competency->name,
                    'competency_type_uuid' => $competencyType->uuid,
                    'competency_type_name' => $competencyType->name,
                    'behaviors' => $behaviors,
                ]);
            }

            return new JsonModel([
                'success' => true,
                'data' => $data
            ]);

        } else if ($request->isPost()) {
            $dataPost = $request->getPost()->toArray();
            
            $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
            $vacancy = $vacancyMapper->fetchOneByUuid($dataPost['vacancy_uuid']);

            $candidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
            $candidate = $candidateMapper->fetchOneByUuid($dataPost['candidate_uuid']);
            
            $form = new RecruitmentSelectionInterviewFormForm($this->adapter, $currentCompany->id, $vacancy->id);

            $dataPost['status'] = isset($dataPost['status']) ? $dataPost['status'] : RecruitmentSelectionInterview::STATUS_REJECTED;

            $form->setData($dataPost);

            if ($form->isValid()) {
                $dataPost = (array) $form->getData();

                $hydrator = new ObjectPropertyHydrator();
                $recruitmentSelectionInterview = new RecruitmentSelectionInterview();
                $hydrator->hydrate($dataPost, $recruitmentSelectionInterview);

                if (!$recruitmentSelectionInterview->status) {
                    $recruitmentSelectionInterview->status = RecruitmentSelectionInterview::STATUS_REJECTED;
                }
               
                $recruitmentSelectionInterview->company_id = $currentCompany->id;
                $recruitmentSelectionInterview->vacancy_id = $vacancy->id;   
                $recruitmentSelectionInterview->candidate_id = $candidate->id;   
                $recruitmentSelectionInterview->user_id = $currentUser->id;
                
                $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
                $result = $recruitmentSelectionInterviewMapper->insert($recruitmentSelectionInterview);

                if ($result) {
                   
                    $this->logger->info('Se agrego la entrevista ' . $recruitmentSelectionInterview->id, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    // Get record by id
                    $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
                    $record = $recruitmentSelectionInterviewMapper->fetchOne($recruitmentSelectionInterview->id);

                  
                    if ($record) {

                        $data = [
                            'success' => true,
                            'id' => $record->id,
                            'data' => 'LABEL_RECORD_ADDED'
                        ];
                    } else {

                        $data = [
                            'success' => false,
                            'data' => 'ERROR_RECORD_NOT_FOUND'
                        ];
                    }
                } else {
                    $data = [
                        'success' => false,
                        'data' => $recruitmentSelectionInterviewMapper->getError()
                    ];
                }

                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages as $fieldname => $field_messages) {

                    $messages[$fieldname] = array_values($field_messages);
                }

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

            return new JsonModel($data);
        }

        return new JsonModel($data);
    }
    
    public function editAction() {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $interview_uuid = $this->params()->fromRoute('interview_uuid');

        if (!$interview_uuid) {
            $data = [
                'success' => false,
                'data' => 'ERROR_INVALID_PARAMETER'
            ];

            return new JsonModel($data);
        }

        $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
        $interview = $recruitmentSelectionInterviewMapper->fetchOneByUuid($interview_uuid);

        $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
        $vacancy = $vacancyMapper->fetchOne($interview->vacancy_id);

        if(!$interview){
           $data = [
               'success' => false,
               'data' => 'ERROR_INVALID_PARAMETER'
           ];

           return new JsonModel($data);
        }

        if ($interview->company_id != $currentCompany->id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_UNAUTHORIZED'
            ]);
        }

        if ($request->isPost()) {
            $form = new RecruitmentSelectionInterviewFormForm($this->adapter, $currentCompany->id, $vacancy->id);
            $dataPost = $request->getPost()->toArray();
            $dataPost['status'] = isset($dataPost['status']) ? $dataPost['status'] : RecruitmentSelectionInterview::STATUS_REJECTED;

            $form->setData($dataPost);

            if ($form->isValid()) {
                $dataPost = (array) $form->getData();

                $hydrator = new ObjectPropertyHydrator();
                $hydrator->hydrate($dataPost, $interview);

                if (!$interview->status) {
                    $interview->status = RecruitmentSelectionInterview::STATUS_REJECTED;
                }

                $candidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
                $candidate = $candidateMapper->fetchOneByUuid($dataPost['candidate_uuid']);
                            
                $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
                $vacancy = $vacancyMapper->fetchOneByUuid($dataPost['vacancy_uuid']);

                $interview->company_id = $currentCompany->id;
                $interview->vacancy_id = $vacancy->id;   
                $interview->candidate_id = $candidate->id;   
                $interview->user_id = $currentUser->id;

                $result = $recruitmentSelectionInterviewMapper->update($interview);
               

                if ($result) {
                    $this->logger->info('Se edito correctamente la entrevista' . $interview->id, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    $data = [
                        'success' => true,
                        'data' => 'LABEL_RECORD_UPDATED'
                    ];
                } else {
                    $data = [
                        'success' => false,
                        'data' => $recruitmentSelectionInterviewMapper->getError()
                    ];
                }

                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages as $fieldname => $field_messages) {
                    $messages[$fieldname] = array_values($field_messages);
                }

                return new JsonModel([
                    'success' => false,
                    'data' => $messages
                ]);
            }
        } else if ($request->isGet()) {
            $hydrator = new ObjectPropertyHydrator();

            $candidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
            $candidate = $candidateMapper->fetchOne($interview->candidate_id);
                        
            $vacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
            $vacancy = $vacancyMapper->fetchOne($candidate->vacancy_id);
            
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            $jobDescription = $jobDescriptionMapper->fetchOne($vacancy->job_description_id);
            
            $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
            $jobDescriptionCompetencies = $jobDescriptionCompetencyMapper->fetchByJobDescriptionId($jobDescription->id);
            
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
            $behaviorCompetencyMapper = BehaviorCompetencyMapper::getInstance($this->adapter);
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);

            $data = [
                'candidate' => [
                    'uuid' => $candidate->uuid,
                    'first_name' => $candidate->first_name,
                    'last_name' => $candidate->last_name,
                    'email' => $candidate->email
                ], 
                'job_description' => [
                    'uuid' => $jobDescription->uuid,
                    'name' => $jobDescription->name,
                    'functions' => $jobDescription->functions, 
                    'objectives' => $jobDescription->objectives,
                    'competencies' => []
                ], 
                'interview' => [
                    'id' => $interview->uuid,
                    'status' => $interview->status,
                    'content' => $interview->content ? json_decode($interview->content) : [],
                    'type' => $interview->type, 
                    'status' => $interview->status,             
                    'points' => $interview->points, 
                    'comment' => $interview->comment,
                ]
            ];

            foreach ($jobDescriptionCompetencies as $jobDescriptionCompetency) {
                $competency = $competencyMapper->fetchOne($jobDescriptionCompetency->competency_id);
                $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
                $behaviorCompetencies = $behaviorCompetencyMapper->fetchByCompetencyId($competency->id);

                $behaviors = [];

                foreach ($behaviorCompetencies as $behaviorCompetency) {
                    $behavior = $behaviorMapper->fetchOne($behaviorCompetency->behavior_id);
                    
                    $behaviors []= [
                        'uuid' => $behavior->uuid,
                        'description' => $behavior->description,
                        'points' => 0,
                        'comment' => '',
                        'competency_uuid' => $competency->uuid,
                    ];
                }

                array_push($data['job_description']['competencies'], [
                    'competency_uuid' => $competency->uuid,
                    'competency_name' => $competency->name,
                    'competency_type_uuid' => $competencyType->uuid,
                    'competency_type_name' => $competencyType->name,
                    'behaviors' => $behaviors,
                ]);
            }

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

            return new JsonModel($data);
        }

        return new JsonModel($data);
    }

    public function deleteAction() {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();

        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('interview_uuid');

        if (!$uuid) {
            $data = [
                'success' => false,
                'data' => 'ERROR_INVALID_PARAMETER'
            ];

            return new JsonModel($data);
        }

        $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
        $recruitmentSelectionInterview = $recruitmentSelectionInterviewMapper->fetchOneByUuid($uuid);
        if (!$recruitmentSelectionInterview) {
            $data = [
                'success' => false,
                'data' => 'ERROR_RECORD_NOT_FOUND'
            ];

            return new JsonModel($data);
        }

        if ($recruitmentSelectionInterview->company_id != $currentCompany->id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_UNAUTHORIZED'
            ]);
        }

        if ($request->isPost()) {

            $result = $recruitmentSelectionInterviewMapper->delete($recruitmentSelectionInterview->id);
            if ($result) {
                $this->logger->info('Se borro la entrevista ' . $recruitmentSelectionInterview->uuid, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_DELETED'
                ];
            } else {

                $data = [
                    'success' => false,
                    'data' => $recruitmentSelectionInterviewMapper->getError()
                ];

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

            return new JsonModel($data);
        }

        return new JsonModel($data);
    }

    public function reportAction() {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $uuid = $this->params()->fromRoute('interview_uuid');

        $recruitmentSelectionInterviewMapper = RecruitmentSelectionInterviewMapper::getInstance($this->adapter);
        $recruitmentSelectionInterview = $recruitmentSelectionInterviewMapper->fetchOneByUuid($uuid);

        $recruitmentSelectionVacancyMapper = RecruitmentSelectionvacancyMapper::getInstance($this->adapter);
        $recruitmentSelectionVacancy = $recruitmentSelectionVacancyMapper->fetchOne($recruitmentSelectionInterview->vacancy_id);


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

        $request = $this->getRequest();
        if ($request->isGet()) {
            //Competencies

            $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
            $competenceTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
            $behaviorCompetencyMapper = BehaviorCompetencyMapper::getInstance($this->adapter);
            $jobDescriptionBehaviorCompetencyMapper = JobDescriptionBehaviorCompetencyMapper::getInstance($this->adapter);
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);

            $competencies = [];

            $jobDescriptionCompetency = $jobDescriptionCompetencyMapper->fetchByJobDescriptionId($recruitmentSelectionVacancy->job_description_id);

            $content = json_decode($recruitmentSelectionInterview->content, true); 

            foreach ($jobDescriptionCompetency as $record) {

                $competency = $competencyMapper->fetchOne($record->competency_id);
                $competenceType = $competenceTypeMapper->fetchOne($competency->competency_type_id);

                if ($competency && $competenceType) {

                    $behaviorCompetencies = $behaviorCompetencyMapper->fetchByCompetencyId($competency->id);
                    $behaviors = [];

                    foreach ($behaviorCompetencies as $rows) {

                        $behavior = $behaviorMapper->fetchOne($rows->behavior_id);
                        $jobDescriptionBehaviorCompetency = $jobDescriptionBehaviorCompetencyMapper->fetchOneByBehavior($recruitmentSelectionVacancy->job_description_id, $record->competency_id, $rows->behavior_id);

                        if ($behavior && $jobDescriptionBehaviorCompetency) {
                            $rowData = [
                                'description' => $behavior->description,
                                'level' => $jobDescriptionBehaviorCompetency->level,
                                'comment' => '',
                                'evaluation' => 0,
                            ];

                            foreach($content as $eval) {
                                if ($eval['competencyUuid'] == $competency->uuid &&
                                    $eval['behaviorUuid'] == $behavior->uuid) {
                                    
                                    $rowData['comment'] = $eval['comment'];
                                    $rowData['evaluation'] = $eval['evaluation'];
                                    
                                    break;
                                }
                            }

                            $behaviors []= $rowData;
                        }
                    }

                    array_push($competencies, [
                        'name' => $competency->name,
                        'description' => $competency->description,
                        'type' => $competenceType->name,
                        'behaviors' => $behaviors
                    ]);
                }
            }

            return $this->renderPDF($currentCompany, $recruitmentSelectionInterview, $competencies);
        }

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

    /**
     * Render PDF
     * @param Company $currentCompany
     * @param recruitmentSelectionInterview $interviewEvaluation
     * @param array $competencies
     * @return mixed
     */
    public function renderPDF($currentCompany, $interviewEvaluation, $competencies) {

        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
       
        //Generate New PDF
        $pdf = new InterviewPDF();

        $pdf->header = '';
        $pdf->footer = '';

        if ($currentCompany) {
            //get company Data
            $companyMapper = CompanyMapper::getInstance($this->adapter);
            $company = $companyMapper->fetchOne($currentCompany->id);

            $target_path = $this->config['leaderslinked.fullpath.company'] . DIRECTORY_SEPARATOR . $company->uuid;

            $pdf->header = $company->header ? $target_path . DIRECTORY_SEPARATOR . $company->header : '';
            $pdf->footer = $company->footer ? $target_path . DIRECTORY_SEPARATOR . $company->footer : '';
        }

        $pdf->SetMargins(10, 0, 10);

        $pdf->AliasNbPages();
        $pdf->AddPage();

        $recruitmentSelectionCandidateMapper = RecruitmentSelectionCandidateMapper::getInstance($this->adapter);
        $recruitmentSelectionVacancyMapper = RecruitmentSelectionVacancyMapper::getInstance($this->adapter);
        $vacancy = $recruitmentSelectionVacancyMapper->fetchOne($interviewEvaluation->vacancy_id);
        $candidate = $recruitmentSelectionCandidateMapper->fetchOne($interviewEvaluation->candidate_id);

        $rows = [
            array(
                'title' => 'Nombre Evaluado: ',
                'content' => $candidate ? ' ' . $candidate->first_name . ' ' . $candidate->last_name : 'No Aplica'
            ),
            array(
                'title' => 'Cargo: ',
                'content' => $vacancy ? ' ' . $vacancy->name : ' No aplica'
            ),
            array(
                'title' => 'Entrevistado por: ',
                'content' => $currentUser ? ' ' . $currentUser->first_name . ' ' . $currentUser->last_name : ' No Aplica '
            ),
            array(
                'title' => 'Estatus del candidato: ',
                'content' => $interviewEvaluation ? ' ' . $interviewEvaluation->status : 'No Aplica'
            ),
            array(
                'title' => 'Comentarios del entrevistador: ',
                'content' => $interviewEvaluation ? ' ' . $interviewEvaluation->comment : 'No Aplica'
            ),
            array(
                'title' => 'Porcentage de adaptibilidad ',
                'content' => $interviewEvaluation ? ' ' . $interviewEvaluation->points : 'No Aplica'
            )
        ];

        $pdf->borderTable('DATOS DE LA ENTREVISTA', $rows);

        // Competencies 
        if (count($competencies) != 0) {

            // add new page

            $pdf->AddPage();

            $competencies_header[] = array('content' => 'Indique el nivel de desempeño del evaluado en relación a sus conductas y actitudes frente a cada valor, según la clasificación siguiente:');

            $pdf->singleTable('Anexo de valores:', $competencies_header);


            // Add scale section
            $pdf->sectionScale();

            $i = 0;

           
        }

        return $pdf->Output();
    }
}