Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 16769 | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use Laminas\Mvc\I18n\Translator;

use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\PerformanceEvaluationFormMapper;
use LeadersLinked\Form\PerformanceEvaluation\PerformanceEvaluationFormForm;
use LeadersLinked\Model\PerformanceEvaluationForm;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Mapper\JobDescriptionMapper;
use LeadersLinked\Mapper\JobDescriptionCompetencyMapper;
use LeadersLinked\Mapper\CompetencyMapper;
use LeadersLinked\Library\PerformanceEvaluationPdf;
use LeadersLinked\Mapper\CompetencyTypeMapper;
use LeadersLinked\Mapper\CompetencyBehaviorMapper;
use LeadersLinked\Mapper\BehaviorMapper;
use LeadersLinked\Mapper\JobDescriptionBehaviorCompetencyMapper;
use LeadersLinked\Mapper\JobDescriptionCompetencyBehaviorMapper;

use LeadersLinked\Mapper\JobDescriptionSubordinateMapper;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\JobDescription;

class PerformanceEvaluationFormController extends AbstractActionController
{

    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;
    
    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;
    
    
    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
    
    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;
    
    
    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->translator   = $translator;
    }

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


        $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');
                    }
                }
            }

            //$isJson = true;
            if ($isJson) {
                $search = $this->params()->fromQuery('search');
                $search = empty($search['value']) ? '' : Functions::sanitizeFilterString($search['value']);

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

                $fields = ['name'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'name';

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

                $performanceEvaluationMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
                $paginator = $performanceEvaluationMapper->fetchAllDataTableByCompanyId($currentCompany->id, $search, $page, $records_x_page, $order_field, $order_direction);

                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $jobsDescription = [];
                
                

                $items = [];
                $records = $paginator->getCurrentItems();
                foreach ($records as $record) {


                    if(!isset($jobsDescription[$record->job_description_id])) {
                        $jobDescription = $jobDescriptionMapper->fetchOne($record->job_description_id);
                     
                        if($jobDescription) {
                            $jobsDescription[ $record->job_description_id ] =  $jobDescription; 
                        }
                    } else {
                        $jobDescription = $jobsDescription[$record->job_description_id];
                    }
                    


                    if ($jobDescription) {


                        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->updated_on);
                  
                        if($record->tests) {
                            $actions = [
                                'link_report' => $this->url()->fromRoute('performance-evaluation/forms/report', ['id' => $record->uuid]),
                                'link_active' => $record->status == PerformanceEvaluationForm::STATUS_ACTIVE ? '' :   $this->url()->fromRoute('performance-evaluation/forms/active', ['id' => $record->uuid]),
                                'link_inactive' => $record->status == PerformanceEvaluationForm::STATUS_INACTIVE ? '' : $this->url()->fromRoute('performance-evaluation/forms/inactive', ['id' => $record->uuid])
                            ]; 
                        } else {
                            
                            $actions = [
                                'link_report' => $this->url()->fromRoute('performance-evaluation/forms/report', ['id' => $record->uuid]),
                                'link_edit' => $this->url()->fromRoute('performance-evaluation/forms/edit', ['id' => $record->uuid]),
                                'link_delete' => $this->url()->fromRoute('performance-evaluation/forms/delete', ['id' => $record->uuid])
                            ]; 
                        }
                        
                        
                        $item = [
                            'id' => $record->id,
                            'name' => $record->name,
                            'job_description' => $jobDescription->name,
                            'tests' => $record->tests,
                            'date' => $dt->format('d/m/Y H:i a'),
                            'status' => $record->status,
                            'actions' =>  $actions
                        ];
                    }

                    array_push($items, $item);
                }

                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'items' => $items,
                        'total' => $paginator->getTotalItemCount(),
                    ]
                ]);
            } else {

                $form = new PerformanceEvaluationFormForm($this->adapter, $currentCompany->id);

                $jobsDescription = [];
                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $records = $jobDescriptionMapper->fetchAllByCompanyId($currentCompany->id);
                foreach($records as $record)
                {
                    $jobsDescription[ $record->uuid ] = $this->url()->fromRoute('performance-evaluation/forms/job-description', ['id' => $record->uuid]);
                    
                    
                }

                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/performance-evaluation-forms/index.phtml');
                $viewModel->setVariables([
                    'jobsDescription' => $jobsDescription,
                    'form' => $form,
                ]);
                return $viewModel;
            }
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);;
        }
    }

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

        $request = $this->getRequest();


        if ($request->isPost()) {
            $dataPost = $request->getPost()->toArray();
            $dataPost['status'] = isset($dataPost['status']) ? $dataPost['status'] : PerformanceEvaluationForm::STATUS_INACTIVE;

            $form = new PerformanceEvaluationFormForm($this->adapter, $currentCompany->id);
            $form->setData($dataPost);

            if ($form->isValid()) {


                $dataPost = (array) $form->getData();

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


                $performanceEvaluation->company_id = $currentCompany->id;
              

                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $jobDescription = $jobDescriptionMapper->fetchOneByUuid($dataPost['job_description_id']);
                $performanceEvaluation->job_description_id = $jobDescription->id;
                $performanceEvaluation->content =  $this->serialize($jobDescription);

                $performanceEvaluationMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
                
                
                $result = $performanceEvaluationMapper->insert($performanceEvaluation);


                if ($result) {
                    $this->logger->info('Se agrego el Formulario de Evaluación de Desempeño : ' . $performanceEvaluation->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                    // Get record by id
                    $record = $performanceEvaluationMapper->fetchOne($performanceEvaluation->id);

                    if ($record) {

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

                        $data = [
                            'success' => false,
                            'data' => 'ERROR_RECORD_NOT_FOUND'
                        ];
                    }
                } else {
                    $data = [
                        'success' => false,
                        'data' => $performanceEvaluationMapper->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();
        $uuid = $this->params()->fromRoute('id');


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

            return new JsonModel($data);
        }

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

            return new JsonModel($data);
        }

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


        if ($request->isPost()) {
            $dataPost = $request->getPost()->toArray();
            $dataPost['status'] = isset($dataPost['status']) ? $dataPost['status'] : PerformanceEvaluationForm::STATUS_INACTIVE;
            
            $form = new PerformanceEvaluationFormForm($this->adapter, $currentCompany->id);
            $form->setData($dataPost);

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

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

                if (!$performanceEvaluation->status) {
                    $performanceEvaluation->status = PerformanceEvaluationForm::STATUS_INACTIVE;
                }

                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $jobDescription = $jobDescriptionMapper->fetchOneByUuid($dataPost['job_description_id']);
                
                $performanceEvaluation->job_description_id = $jobDescription->id;
                $performanceEvaluation->content =  $this->serialize($jobDescription);
                
                
                $result = $performanceEvaluationMapper->update($performanceEvaluation);

                if ($result) {
                    $this->logger->info('Se actualizo el Formulario de Evaluación de Desempeño : ' . $performanceEvaluation->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    $data = [
                        'success' => true,
                        'data' => 'LABEL_RECORD_UPDATED'
                    ];
                } else {
                    $data = [
                        'success' => false,
                        'data' => $performanceEvaluationMapper->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()) {


            $content = json_decode($performanceEvaluation->content);
            
            $data = [
                'success' => true,
                'data' => [
                    'name' => $performanceEvaluation->name,
                    'description' => $performanceEvaluation->description,
                    'job_description_id' =>  $content->uuid,
                    'status' => $performanceEvaluation->status,
                    'content' => $content,
                    
                ]
            ];

            return new JsonModel($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('id');

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

            return new JsonModel($data);
        }

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

            return new JsonModel($data);
        }

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

        if ($request->isPost()) {


            $result = $performanceEvaluationMapper->delete($performanceEvaluation->id);
            if ($result) {
                $this->logger->info('Se borro el Formulario de Evaluación de Desempeño : ' . $performanceEvaluation->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

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

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

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

            return new JsonModel($data);
        }

        return new JsonModel($data);
    }
    
    public function activeAction()
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        if (!$uuid) {
            $data = [
                'success' => false,
                'data' => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $performanceEvaluationMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
        $performanceEvaluation = $performanceEvaluationMapper->fetchOneByUuid($uuid);
        if (!$performanceEvaluation) {
            $data = [
                'success' => false,
                'data' => 'ERROR_RECORD_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if ($performanceEvaluation->company_id != $currentCompany->id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        if($performanceEvaluation->status == PerformanceEvaluationForm::STATUS_ACTIVE) {
            return new JsonModel([
                'success' => false,
                'data' =>  'ERROR_RECORD_IS_CURRENTLY_ACTIVE'
            ]);
           
        }
        
        if ($request->isPost()) {
            
            
            $result = $performanceEvaluationMapper->active($performanceEvaluation);
            if ($result) {
                $this->logger->info('Se activo el Formulario de Evaluación de Desempeño : ' . $performanceEvaluation->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_ACTIVED'
                ];
            } else {
                
                $data = [
                    'success' => false,
                    'data' => $performanceEvaluationMapper->getError()
                ];
                
                return new JsonModel($data);
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    public function inactiveAction()
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        if (!$uuid) {
            $data = [
                'success' => false,
                'data' => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $performanceEvaluationMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
        $performanceEvaluation = $performanceEvaluationMapper->fetchOneByUuid($uuid);
        if (!$performanceEvaluation) {
            $data = [
                'success' => false,
                'data' => 'ERROR_RECORD_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if ($performanceEvaluation->company_id != $currentCompany->id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        if($performanceEvaluation->status == PerformanceEvaluationForm::STATUS_INACTIVE) {
            return new JsonModel([
                'success' => false,
                'data' =>  'ERROR_RECORD_IS_CURRENTLY_INACTIVE'
            ]);
            
        }
        
        if ($request->isPost()) {
            
            
            $result = $performanceEvaluationMapper->inactive($performanceEvaluation);
            if ($result) {
                $this->logger->info('Se inactivo el Formulario de Evaluación de Desempeño : ' . $performanceEvaluation->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_ACTIVED'
                ];
            } else {
                
                $data = [
                    'success' => false,
                    'data' => $performanceEvaluationMapper->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()
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        if (!$uuid) {
            $data = [
                'success' => false,
                'data' => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $performanceEvaluationMapper = PerformanceEvaluationFormMapper::getInstance($this->adapter);
        $performanceEvaluation = $performanceEvaluationMapper->fetchOneByUuid($uuid);
        if (!$performanceEvaluation) {
            $data = [
                'success' => false,
                'data' => 'ERROR_RECORD_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if ($performanceEvaluation->company_id != $currentCompany->id) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        if($performanceEvaluation->status == PerformanceEvaluationForm::STATUS_INACTIVE) {
            return new JsonModel([
                'success' => false,
                'data' =>  'ERROR_RECORD_IS_CURRENTLY_INACTIVE'
            ]);
            
        }

        $request = $this->getRequest();
        if ($request->isGet()) {
            
            $filename = Functions::normalizeStringFilename($performanceEvaluation->name . '-' . date('Y-m-d H:i a') . '.pdf');
            
            
            
            
            $content = base64_encode($this->renderPDF($performanceEvaluation));
            $data = [
                'success' => true,
                'data' => [
                    'basename' => $filename,
                    'content' => $content
                ]
            ];
            
            return new JsonModel($data);
            
            /*
            
            $content = $this->renderPdf($currentCompany, $jobDescription);
            $response = new Response();
            $response->setStatusCode(200);
            $response->setContent($content);
            
            
            
            $headers = $response->getHeaders();
            $headers->clearHeaders();
            
            $headers->addHeaderLine('Content-Description: File Transfer');
            $headers->addHeaderLine('Content-Type: application/pdf');
            //$headers->addHeaderLine('Content-Disposition: attachment; filename=' . $filename);
            $headers->addHeaderLine('Content-Transfer-Encoding: binary');
            $headers->addHeaderLine('Expires: 0');
            $headers->addHeaderLine('Cache-Control: must-revalidate');
            $headers->addHeaderLine('Pragma: public');
            return $response;
            */
            



            return ;
        } else {


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

    /**
     * Render PDF
     * @param PerformanceEvaluationForm $performanceEvaluation

     * @return mixed
     */
    private function renderPDF($performanceEvaluation)
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();
        

        //Generate New PDF
        $pdf = new PerformanceEvaluationPdf();

        $target_path = $this->config['leaderslinked.fullpath.company'] . DIRECTORY_SEPARATOR . $currentCompany->uuid;
        $header = $currentCompany->header ? $target_path . DIRECTORY_SEPARATOR . $currentCompany->header : '';
        if (empty($header) || !file_exists($header)) {
            $header = $this->config['leaderslinked.images_default.company_pdf_header'];
        }

        $footer = $currentCompany->footer ? $target_path . DIRECTORY_SEPARATOR . $currentCompany->footer : '';
        if (empty($footer) || !file_exists($footer)) {
            $footer = $this->config['leaderslinked.images_default.company_pdf_footer'];
        }
        
        $content = json_decode($performanceEvaluation->content);

        $pdf->header = $header;
        $pdf->footer = $footer;
        $pdf->translator = $this->translator;

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

        $pdf->AliasNbPages();
        $pdf->AddPage();
        
        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $performanceEvaluation->updated_on);


        $rows = [
            [
                'title' => $this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_POSITION') . ' : ',
                'content' => $content->name,
            ],
            [
                'title' => $this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_EVALUATED')  . ' : ',
                'content' => ''
            ],

            [
                'title' => $this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_EVALUATE_SIGNATURE') . ' : ',
                'content' => ''
            ],
            [
                'title' => $this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_EVALUATOR') . ' : ',
                'content' => ''
            ],
            [
                'title' => $this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_EVALUATOR_SIGNATURE') . ' : ',
                'content' => ''
            ],
            [
                'title' => $this->translator->translate( 'LABEL_PDF_PERFORMANCE_EVALUATION_MANAGER_SIGNATURE') . ' : ',
                'content' => ''
            ],
            [
                'title' => $this->translator->translate('LABEL_DATE'),
                'content' => $dt->format('d/m/Y H:i a')
            ]
        ];
        


        $pdf->borderTable($this->translator->translate('LABEL_PDF_PERFORMANCE_EVALUATION_TITLE'), $rows);
        
        $pdf->evaluationTable();


        //Sections 
        /*
        $sections = json_decode($performanceEvaluation->content, true);

        for ($s = 0; $s < count($sections); $s++) {

            $pdf->singleTable($sections[$s]['title'], [
                array(
                    'content' => $sections[$s]['type'] != 'multiple' ? $sections[$s]['text'] : ''
                )
            ]);

            if ($sections[$s]['type'] == 'multiple') {

                $pdf->titleOptionTable($sections[$s]['text']);

                for ($o = 0; $o < count($sections[$s]['options']); $o++) {

                    $pdf->optionTable($sections[$s]['options'][$o]['title']);
                }
                $pdf->Ln();
            }
            if ($s % 2 == 0 && $s > 1) {
                $pdf->AddPage();
            }
        }*/
        // Competencies 
        if ($content->competencies_selected) {

            // add new page

            $pdf->AddPage();
            /*
            $competencies_header[] = [
                '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;

            $max = count($content->competencies_selected);
            for($i = 0; $i < $max; $i++) 
            {

                $competency_selected = $content->competencies_selected[$i];

                $j = $i + 1;
                $last = $j == $max;
                $pdf->competencyTable($i, $competency_selected, $content->competencies, $content->competency_types, $content->behaviors, $last);

                /*
                $pdf->singleTable('Comentarios Finales :', [array('content' => '')]);

                if ($i % 3 == 0 && $i < $max) {
                    $pdf->AddPage();
                }*/
            }
            
        }

        return $pdf->Output('S');
    }

    public function jobDescriptionAction()
    {


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

            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            $currentCompany = $currentUserPlugin->getCompany();


            $id = $this->params()->fromRoute('id');
            if (!$id) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_INVALID_PARAMETER'
                ];

                return new JsonModel($data);
            }

            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            $jobDescription = $jobDescriptionMapper->fetchOneByUuid($id);
            if (!$jobDescription) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_RECORD_NOT_FOUND'
                ];

                return new JsonModel($data);
            }

            if ($currentCompany && $jobDescription->company_id != $currentCompany->id) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];

                return new JsonModel($data);
            }

            if ($jobDescription->job_description_id_boss) {
                
                $jobDescriptionBoss = $jobDescriptionMapper->fetchOne($jobDescription->job_description_id_boss);
                if ($jobDescriptionBoss) {
                    $job_description_uuid_boss = $jobDescriptionBoss->uuid;
                } else {
                    $job_description_uuid_boss = '';
                }
            } else {
                $job_description_uuid_boss = '';
            }
            
            if($currentCompany) {
                $records = $jobDescriptionMapper->fetchAllActiveByCompanyId($currentCompany->id);
            } else {
                $jobDescriptionMapper->fetchAllActiveByDefault();
            }
            
            $jobsDescription = [];
            
            foreach ($records as $record)
            {
                
                if($jobDescription->id != $record->id) {
                    
                    $jobsDescription[ $record->uuid ] = $record->name;
                }
            }
            
            $behaviors = [];
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
            
            
            if($currentCompany) {
                $records = $behaviorMapper->fetchAllActiveByCompanyId($currentCompany->id);
            } else {
                $records = $behaviorMapper->fetchAllActiveByDefault();
            }
            
            $behaviorIds = [];
            foreach($records as $record)
            {
                
                $behaviorIds[ $record->id ] = $record->uuid;
                
                array_push($behaviors, [
                    'uuid' => $record->uuid,
                    'description' => $record->description
                ]);
            }
            
            
            $competencyTypes = [];
            
            
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
            
            if($currentCompany) {
                $records = $competencyTypeMapper->fetchAllActiveByCompanyId($currentCompany->id);
            } else {
                $records = $competencyTypeMapper->fetchAllActiveByDefault();
            }
            
            
            $competencyTypeIds = [];
            foreach($records as $record)
            {
                $competencyTypeIds[ $record->id ] =  $record->uuid;
                
                
                array_push($competencyTypes, [
                    'uuid' => $record->uuid,
                    'name' => $record->name,
                ]);
            }
            
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
            if($currentCompany) {
                $records = $competencyMapper->fetchAllActiveByCompanyId($currentCompany->id);
            } else {
                $records = $competencyMapper->fetchAllActiveByDefault();
            }
            
            $competencyBehaviorMapper = CompetencyBehaviorMapper::getInstance($this->adapter);
            
            
            
            $competencies = [];
            
            foreach($records as $record)
            {
                if(!isset($competencyTypeIds[ $record->competency_type_id ])) {
                    continue;
                }
                
                $behaviors_by_competency = [];
                
                $competencyBehaviors = $competencyBehaviorMapper->fetchAllByCompetencyId($record->id);
                foreach($competencyBehaviors as $competencyBehavior)
                {
                    if(!isset($behaviorIds[ $competencyBehavior->behavior_id ])) {
                        continue;
                    }
                    
                    array_push($behaviors_by_competency, $behaviorIds[ $competencyBehavior->behavior_id ]);
                }
                
                
                if($behaviors_by_competency) {
                    array_push($competencies, [
                        'competency_type_uuid' => $competencyTypeIds[ $record->competency_type_id ],
                        'uuid' => $record->uuid,
                        'name' => $record->name,
                        'behaviors' => $behaviors_by_competency,
                    ]);
                }
                
                
            }
            
            
            
            
            
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            if($currentCompany) {
                $records = $jobDescriptionMapper->fetchAllActiveByCompanyId($currentCompany->id);
            } else {
                $jobDescriptionMapper->fetchAllActiveByDefault();
            }
            
            $jobsDescription = [];
            
            foreach ($records as $record)
            {
                $jobsDescription[ $record->uuid ] = $record->name;
            }
            
            
            $data = [
                'name' => $jobDescription->name,
                'functions' => $jobDescription->functions,
                'objectives' => $jobDescription->objectives,
                'status' => $jobDescription->status,
                'job_description_id_boss' => $job_description_uuid_boss,
                'jobs_description' => $jobsDescription,
                'subordinates_selected' => [],
                'competencies_selected' => [],
                'behaviors' => $behaviors,
                'competency_types' => $competencyTypes,
                'competencies' => $competencies,
            ];
            
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
            
            $competencyTypes = [];
            
            $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
            $jobDescriptionCompetencyBehaviorMapper = JobDescriptionCompetencyBehaviorMapper::getInstance($this->adapter);
            
            $jobDescriptionCompetencies = $jobDescriptionCompetencyMapper->fetchAllByJobDescriptionId($jobDescription->id);
            foreach($jobDescriptionCompetencies as $jobDescriptionCompetency)
            {
                
                
                
                $competency = $competencyMapper->fetchOne($jobDescriptionCompetency->competency_id);
                if(!$competency) {
                    continue;
                }
                
                if(isset($competencyTypes[$competency->competency_type_id])) {
                    $competencyType = $competencyTypes[$competency->competency_type_id];
                } else {
                    
                    $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
                    if(!$competencyType) {
                        continue;
                    }
                    
                    $competencyTypes[$competency->competency_type_id] = $competencyType;
                }
                
                $competency_selected = [
                    'uuid' => $competency->uuid,
                    'competency_type_uuid' => $competencyType->uuid,
                    'behaviors' => []
                ];
                
                
                $jobDescriptionCompetencyBehaviors = $jobDescriptionCompetencyBehaviorMapper->fetchAllByJobDescriptionIdAndCompetencyId($jobDescriptionCompetency->job_description_id, $jobDescriptionCompetency->competency_id);
                foreach($jobDescriptionCompetencyBehaviors as $jobDescriptionCompetencyBehavior)
                {
                    $behavior = $behaviorMapper->fetchOne($jobDescriptionCompetencyBehavior->behavior_id);
                    if($behavior) {
                        array_push($competency_selected['behaviors'], ['uuid' => $behavior->uuid, 'level' => $jobDescriptionCompetencyBehavior->level]);
                        
                    }
                    
                }
                
                array_push($data['competencies_selected'], $competency_selected);
                
                
                
            }
            
            $jobDescriptionSubordinateMapper = JobDescriptionSubordinateMapper::getInstance($this->adapter);
            $jobDescriptionSubordinates = $jobDescriptionSubordinateMapper->fetchAllByJobDescriptionIdTopLevel($jobDescription->id);
            
            foreach($jobDescriptionSubordinates as $jobDescriptionSubordinate)
            {
                $jobDescriptionForSubordinate = $jobDescriptionMapper->fetchOne($jobDescriptionSubordinate->job_description_id_low_level);
                if($jobDescriptionForSubordinate) {
                    array_push($data['subordinates_selected'], ['uuid' => $jobDescriptionForSubordinate->uuid ]);
                }
            }
            
            
            
            $response = [
                'success' => true,
                'data' => $data
            ];

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

            return new JsonModel($data);
        }
    }
    
    /**
     * 
     * @param JobDescription $jobDescription
     * @return String
     */
    public function serialize($jobDescription)
    {
        

       
        
        $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
        $competencyMapper = CompetencyMapper::getInstance($this->adapter);
        $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
        
        $competencyTypes = [];
        $competencies = [];
        $behaviors = [];
        $competencies_selected = [];
        $subordinates_selected = [];
        
        $jobDescriptionCompetencyMapper = JobDescriptionCompetencyMapper::getInstance($this->adapter);
        $jobDescriptionCompetencyBehaviorMapper = JobDescriptionCompetencyBehaviorMapper::getInstance($this->adapter);
        
        $jobDescriptionCompetencies = $jobDescriptionCompetencyMapper->fetchAllByJobDescriptionId($jobDescription->id);
        foreach($jobDescriptionCompetencies as $jobDescriptionCompetency)
        {
            
            if(isset($competencies[$jobDescriptionCompetency->competency_id])) {
                $competency = $competencies[$jobDescriptionCompetency->competency_id];
            } else {
                
                $competency = $competencyMapper->fetchOne($jobDescriptionCompetency->competency_id);
                if(!$competency) {
                    continue;
                }
                
                
                
                $competencies[$jobDescriptionCompetency->competency_id] = new \stdClass();
                $competencies[$jobDescriptionCompetency->competency_id]->uuid = $competency->uuid;
                $competencies[$jobDescriptionCompetency->competency_id]->name = $competency->name;
                $competencies[$jobDescriptionCompetency->competency_id]->description = $competency->description;

            }
            
            
            if(isset($competencyTypes[$competency->competency_type_id])) {
                $competencyType = $competencyTypes[$competency->competency_type_id];
            } else {
                
                $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
                if(!$competencyType) {
                    continue;
                }
                
                $competencyTypes[$competency->competency_type_id] = new \stdClass();
                $competencyTypes[$competency->competency_type_id]->uuid = $competencyType->uuid;
                $competencyTypes[$competency->competency_type_id]->name = $competencyType->name;
                $competencyTypes[$competency->competency_type_id]->description = $competencyType->description;
  
            }
            
            $competency_selected = [
                'uuid' => $competency->uuid,
                'competency_type_uuid' => $competencyType->uuid,
                'behaviors' => []
            ];
            
            
            $jobDescriptionCompetencyBehaviors = $jobDescriptionCompetencyBehaviorMapper->fetchAllByJobDescriptionIdAndCompetencyId($jobDescriptionCompetency->job_description_id, $jobDescriptionCompetency->competency_id);
            foreach($jobDescriptionCompetencyBehaviors as $jobDescriptionCompetencyBehavior)
            {
                
                
                if(isset($behaviors[$jobDescriptionCompetencyBehavior->behavior_id])) {
                    $behavior = $behaviors[$jobDescriptionCompetencyBehavior->behavior_id];
                } else {
                    
                    $behavior = $behaviorMapper->fetchOne($jobDescriptionCompetencyBehavior->behavior_id);
                    if(!$behavior) {
                       
                        continue;
                    }
                    
                    $behaviors[$jobDescriptionCompetencyBehavior->behavior_id] = new \stdClass();
                    $behaviors[$jobDescriptionCompetencyBehavior->behavior_id]->uuid = $behavior->uuid;
                    $behaviors[$jobDescriptionCompetencyBehavior->behavior_id]->description = $behavior->description;

                }
                


                
                array_push($competency_selected['behaviors'], ['uuid' => $behavior->uuid, 'level' => $jobDescriptionCompetencyBehavior->level]);
               
                
            }
            
            array_push($competencies_selected, $competency_selected);
            
            
            
        }

        
        $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
        
        $jobDescriptionSubordinateMapper = JobDescriptionSubordinateMapper::getInstance($this->adapter);
        $jobDescriptionSubordinates = $jobDescriptionSubordinateMapper->fetchAllByJobDescriptionIdTopLevel($jobDescription->id);
        
        foreach($jobDescriptionSubordinates as $jobDescriptionSubordinate)
        {
            $jobDescriptionForSubordinate = $jobDescriptionMapper->fetchOne($jobDescriptionSubordinate->job_description_id_low_level);
            if($jobDescriptionForSubordinate) {
                array_push($subordinates_selected, ['uuid' => $jobDescriptionForSubordinate->uuid ]);
            }
            
            
            
        }
        
        if($jobDescription->job_description_id_boss) {
        
            $jobDescriptionBoss = $jobDescriptionMapper->fetchOne($jobDescription->job_description_id_boss);
            if($jobDescriptionBoss) {
                $job_description_id_boss = $jobDescriptionBoss->uuid;
            }
        } else {
            $job_description_id_boss = '';
        }
        
        $content = [
            'uuid' => $jobDescription->uuid,
            'name' => $jobDescription->name,
            'functions' => $jobDescription->functions,
            'objectives' => $jobDescription->objectives,
            'job_description_id_boss' => $job_description_id_boss,
            'competency_types' => $competencyTypes,
            'competencies' => $competencies,
            'behaviors' => $behaviors,
            'competencies_selected' => $competencies_selected,
            'subordinates_selected' => $subordinates_selected,
            
        ]; 
        
        return json_encode($content);
    }
}