Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 15355 | Rev 15371 | Ir a la última revisión | | Comparar con el anterior | Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 www 1 
<?php
1098 geraldo 2 
 
1 www 3 
declare(strict_types=1);
4 
 
5 
namespace LeadersLinked\Controller;
6 
 
7 
use Laminas\Db\Adapter\AdapterInterface;
8 
use Laminas\Cache\Storage\Adapter\AbstractAdapter;
9 
use Laminas\Mvc\Controller\AbstractActionController;
10 
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
11 
use Laminas\Log\LoggerInterface;
12 
use Laminas\View\Model\ViewModel;
13 
use Laminas\View\Model\JsonModel;
14 
use LeadersLinked\Library\Functions;
15 
use LeadersLinked\Mapper\CompetencyMapper;
16 
use LeadersLinked\Model\Competency;
17 
use LeadersLinked\Form\CompetencyForm;
18 
use LeadersLinked\Mapper\CompetencyTypeMapper;
1142 geraldo 19 
use LeadersLinked\Model\CompetencyType;
14989 efrain 20 
use LeadersLinked\Mapper\CompetencyBehaviorMapper;
21 
use LeadersLinked\Model\CompetencyBehavior;
1320 efrain 22 
use LeadersLinked\Mapper\BehaviorMapper;
14989 efrain 23 
use LeadersLinked\Form\BehaviorForm;
1 www 24 
 
14989 efrain 25 
 
15133 stevensc 26 
class CompetencyController extends AbstractActionController {
1 www 27 
 
28 
    /**
29 
     *
30 
     * @var AdapterInterface
31 
     */
32 
    private $adapter;
1098 geraldo 33 
 
1 www 34 
    /**
35 
     *
36 
     * @var AbstractAdapter
37 
     */
38 
    private $cache;
1098 geraldo 39 
 
1 www 40 
    /**
41 
     *
42 
     * @var  LoggerInterface
43 
     */
44 
    private $logger;
45 
 
46 
    /**
47 
     *
48 
     * @var array
49 
     */
50 
    private $config;
1098 geraldo 51 
 
1 www 52 
    /**
53 
     *
54 
     * @param AdapterInterface $adapter
55 
     * @param AbstractAdapter $cache
56 
     * @param LoggerInterface $logger
57 
     * @param array $config
58 
     */
15133 stevensc 59 
    public function __construct($adapter, $cache, $logger, $config) {
1098 geraldo 60 
        $this->adapter = $adapter;
61 
        $this->cache = $cache;
62 
        $this->logger = $logger;
63 
        $this->config = $config;
1 www 64 
    }
1098 geraldo 65 
 
15133 stevensc 66 
    public function indexAction() {
28 efrain 67 
        $currentUserPlugin = $this->plugin('currentUserPlugin');
68 
        $currentUser = $currentUserPlugin->getUser();
69 
        $currentCompany = $currentUserPlugin->getCompany();
1098 geraldo 70 
 
1 www 71 
        $request = $this->getRequest();
1098 geraldo 72 
 
73 
        $headers = $request->getHeaders();
74 
 
1 www 75 
        $request = $this->getRequest();
1098 geraldo 76 
        if ($request->isGet()) {
77 
 
78 
 
79 
            $headers = $request->getHeaders();
80 
 
1 www 81 
            $isJson = false;
1098 geraldo 82 
            if ($headers->has('Accept')) {
1 www 83 
                $accept = $headers->get('Accept');
1098 geraldo 84 
 
1 www 85 
                $prioritized = $accept->getPrioritized();
1098 geraldo 86 
 
87 
                foreach ($prioritized as $key => $value) {
1 www 88 
                    $raw = trim($value->getRaw());
1098 geraldo 89 
 
90 
                    if (!$isJson) {
1 www 91 
                        $isJson = strpos($raw, 'json');
92 
                    }
93 
                }
94 
            }
1098 geraldo 95 
 
96 
            if ($isJson) {
15133 stevensc 97 
                $search = $this->params()->fromQuery('search', []);
98 
                $search = empty($search['value']) ? '' : filter_var($search['value'], FILTER_SANITIZE_STRING);
1098 geraldo 99 
 
100 
                $page = intval($this->params()->fromQuery('start', 1), 10);
101 
                $records_x_page = intval($this->params()->fromQuery('length', 10), 10);
102 
                $order = $this->params()->fromQuery('order', []);
103 
                $order_field = empty($order[0]['column']) ? 99 : intval($order[0]['column'], 10);
104 
                $order_direction = empty($order[0]['dir']) ? 'ASC' : strtoupper(filter_var($order[0]['dir'], FILTER_SANITIZE_STRING));
105 
 
106 
                $fields = ['type', 'name'];
1 www 107 
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'name';
1098 geraldo 108 
 
109 
                if (!in_array($order_direction, ['ASC', 'DESC'])) {
1 www 110 
                    $order_direction = 'ASC';
111 
                }
1098 geraldo 112 
 
14989 efrain 113 
                $competencyMapper = CompetencyMapper::getInstance($this->adapter);
1098 geraldo 114 
 
115 
                if ($currentCompany) {
14989 efrain 116 
                    $paginator = $competencyMapper->fetchAllDataTableByCompanyId($currentCompany->id, $search, $page, $records_x_page, $order_field, $order_direction);
28 efrain 117 
                } else {
14989 efrain 118 
                    $paginator = $competencyMapper->fetchAllDataTable($search, $page, $records_x_page, $order_field, $order_direction);
28 efrain 119 
                }
1 www 120 
                $items = [];
121 
                $records = $paginator->getCurrentItems();
1098 geraldo 122 
                foreach ($records as $record) {
1 www 123 
                    $item = [
124 
                        'type' => $record['type'],
125 
                        'name' => $record['name'],
126 
                        'status' => $record['status'],
127 
                        'actions' => [
1098 geraldo 128 
                            'link_edit' => $this->url()->fromRoute('settings/competencies/edit', ['id' => $record['uuid']]),
129 
                            'link_delete' => $this->url()->fromRoute('settings/competencies/delete', ['id' => $record['uuid']])
130 
                        ]
1 www 131 
                    ];
1098 geraldo 132 
 
1 www 133 
                    array_push($items, $item);
134 
                }
1098 geraldo 135 
 
1 www 136 
                return new JsonModel([
137 
                    'success' => true,
138 
                    'data' => [
139 
                        'items' => $items,
140 
                        'total' => $paginator->getTotalItemCount(),
141 
                    ]
142 
                ]);
1098 geraldo 143 
            } else {
144 
                if ($currentCompany) {
66 efrain 145 
                    $form = new CompetencyForm($this->adapter, $currentCompany->id);
146 
                } else {
147 
                    $form = new CompetencyForm($this->adapter);
148 
                }
15133 stevensc 149 
 
150 
 
1 www 151 
                $this->layout()->setTemplate('layout/layout-backend');
152 
                $viewModel = new ViewModel();
153 
                $viewModel->setTemplate('leaders-linked/competencies/index.phtml');
14989 efrain 154 
                $viewModel->setVariables([
155 
                    'form' =>  $form,
156 
                ]);
1098 geraldo 157 
                return $viewModel;
158 
            }
1 www 159 
        } else {
160 
            return new JsonModel([
161 
                'success' => false,
162 
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
1098 geraldo 163 
            ]);
1 www 164 
        }
165 
    }
1098 geraldo 166 
 
15133 stevensc 167 
    public function addAction() {
1 www 168 
        $currentUserPlugin = $this->plugin('currentUserPlugin');
169 
        $currentUser = $currentUserPlugin->getUser();
28 efrain 170 
        $currentCompany = $currentUserPlugin->getCompany();
1098 geraldo 171 
 
1 www 172 
        $request = $this->getRequest();
1098 geraldo 173 
 
14989 efrain 174 
        if ($request->isGet()) {
15133 stevensc 175 
 
176 
 
14989 efrain 177 
            $behaviors = [];
15133 stevensc 178 
 
14989 efrain 179 
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
15133 stevensc 180 
 
15369 efrain 181 
            if($currentCompany) {
182 
                $records = $behaviorMapper->fetchAllActiveByCompanyId($currentCompany->id);
183 
            } else {
184 
                $records = $behaviorMapper->fetchAllActiveByDefault();
185 
            }
15133 stevensc 186 
 
15369 efrain 187 
 
15133 stevensc 188 
            foreach($records as $record)
189 
            {
14989 efrain 190 
                array_push($behaviors, [
191 
                    'id' => $record->uuid,
192 
                    'description' => $record->description,
193 
                    'checked' => 0
15133 stevensc 194 
 
14989 efrain 195 
                ]);
196 
            }
15133 stevensc 197 
 
14989 efrain 198 
            return new JsonModel([
199 
                'success' => true,
200 
                'data' => [
201 
                    'behaviors' => $behaviors
202 
                ]
203 
            ]);
15133 stevensc 204 
 
205 
 
206 
 
14989 efrain 207 
        } else   if ($request->isPost()) {
1098 geraldo 208 
            if ($currentCompany) {
66 efrain 209 
                $form = new CompetencyForm($this->adapter, $currentCompany->id);
210 
            } else {
211 
                $form = new CompetencyForm($this->adapter);
212 
            }
1 www 213 
            $dataPost = $request->getPost()->toArray();
1098 geraldo 214 
 
1 www 215 
            $form->setData($dataPost);
1098 geraldo 216 
 
217 
            if ($form->isValid()) {
1 www 218 
                $dataPost = (array) $form->getData();
219 
                $dataPost['status'] = $dataPost['status'] ? $dataPost['status'] : Competency::STATUS_INACTIVE;
1098 geraldo 220 
 
14989 efrain 221 
                $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
222 
                $competencyType = $competencyTypeMapper->fetchOneByUuid($dataPost['competency_type_id']);
223 
                $dataPost['competency_type_id'] = $competencyType->id;
1 www 224 
 
28 efrain 225 
 
1 www 226 
                $hydrator = new ObjectPropertyHydrator();
14989 efrain 227 
                $competency = new Competency();
1098 geraldo 228 
 
14989 efrain 229 
                $hydrator->hydrate($dataPost, $competency);
1098 geraldo 230 
 
231 
                if ($currentCompany) {
14989 efrain 232 
                    $competency->company_id = $currentCompany->id;
28 efrain 233 
                }
1 www 234 
 
14989 efrain 235 
                $competencyMapper = CompetencyMapper::getInstance($this->adapter);
236 
                $result = $competencyMapper->insert($competency);
1098 geraldo 237 
 
238 
                if ($result) {
1151 geraldo 239 
 
14989 efrain 240 
                    $competencyBehaviorMapper = CompetencyBehaviorMapper::getInstance($this->adapter);
1320 efrain 241 
                    $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
1147 geraldo 242 
 
14989 efrain 243 
                    $competencyBehaviorMapper->deleteAllBCompetencyId($competency->id);
1140 geraldo 244 
 
14989 efrain 245 
                    $behavior_ids = $dataPost['behavior_id'];
1140 geraldo 246 
 
14989 efrain 247 
                    foreach ($behavior_ids as $behavior_id) {
1140 geraldo 248 
 
14989 efrain 249 
                        $behavior = $behaviorMapper->fetchOneByUuid($behavior_id);
1147 geraldo 250 
                        if ($behavior) {
14989 efrain 251 
                            $behaviorCompetency = new CompetencyBehavior();
252 
                            $behaviorCompetency->competency_id = $competency->id;
1151 geraldo 253 
                            $behaviorCompetency->behavior_id = $behavior->id;
14989 efrain 254 
                            $competencyBehaviorMapper->insert($behaviorCompetency);
1147 geraldo 255 
                        }
1140 geraldo 256 
                    }
1151 geraldo 257 
 
14989 efrain 258 
                    $this->logger->info('Se agrego la competencia ' . $competency->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
1140 geraldo 259 
 
1 www 260 
                    $data = [
1098 geraldo 261 
                        'success' => true,
262 
                        'data' => 'LABEL_RECORD_ADDED'
1 www 263 
                    ];
264 
                } else {
265 
                    $data = [
1098 geraldo 266 
                        'success' => false,
14989 efrain 267 
                        'data' => $competencyMapper->getError()
1 www 268 
                    ];
269 
                }
1098 geraldo 270 
 
1 www 271 
                return new JsonModel($data);
272 
            } else {
273 
                $messages = [];
274 
                $form_messages = (array) $form->getMessages();
1098 geraldo 275 
                foreach ($form_messages as $fieldname => $field_messages) {
276 
 
1 www 277 
                    $messages[$fieldname] = array_values($field_messages);
278 
                }
1098 geraldo 279 
 
1 www 280 
                return new JsonModel([
1098 geraldo 281 
                    'success' => false,
282 
                    'data' => $messages
1 www 283 
                ]);
284 
            }
285 
        } else {
286 
            $data = [
287 
                'success' => false,
288 
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
289 
            ];
1098 geraldo 290 
 
1 www 291 
            return new JsonModel($data);
292 
        }
1098 geraldo 293 
 
1 www 294 
        return new JsonModel($data);
295 
    }
1098 geraldo 296 
 
15133 stevensc 297 
    public function editAction() {
1 www 298 
        $currentUserPlugin = $this->plugin('currentUserPlugin');
299 
        $currentUser = $currentUserPlugin->getUser();
28 efrain 300 
        $currentCompany = $currentUserPlugin->getCompany();
1098 geraldo 301 
 
1 www 302 
        $request = $this->getRequest();
303 
        $uuid = $this->params()->fromRoute('id');
304 
 
1098 geraldo 305 
 
306 
        if (!$uuid) {
1 www 307 
            $data = [
1098 geraldo 308 
                'success' => false,
309 
                'data' => 'ERROR_INVALID_PARAMETER'
1 www 310 
            ];
1098 geraldo 311 
 
1 www 312 
            return new JsonModel($data);
313 
        }
314 
 
14989 efrain 315 
        $competencyMapper = CompetencyMapper::getInstance($this->adapter);
316 
        $competency = $competencyMapper->fetchOneByUuid($uuid);
317 
        if (!$competency) {
1 www 318 
            $data = [
1098 geraldo 319 
                'success' => false,
320 
                'data' => 'ERROR_RECORD_NOT_FOUND'
1 www 321 
            ];
1098 geraldo 322 
 
1 www 323 
            return new JsonModel($data);
324 
        }
1098 geraldo 325 
 
326 
        if ($currentCompany) {
14989 efrain 327 
            if ($competency->company_id != $currentCompany->id) {
28 efrain 328 
                $data = [
1098 geraldo 329 
                    'success' => false,
330 
                    'data' => 'ERROR_UNAUTHORIZED'
28 efrain 331 
                ];
1098 geraldo 332 
 
28 efrain 333 
                return new JsonModel($data);
334 
            }
335 
        } else {
14989 efrain 336 
            if ($competency->company_id) {
28 efrain 337 
                $data = [
1098 geraldo 338 
                    'success' => false,
339 
                    'data' => 'ERROR_UNAUTHORIZED'
28 efrain 340 
                ];
1098 geraldo 341 
 
28 efrain 342 
                return new JsonModel($data);
343 
            }
344 
        }
14989 efrain 345 
        if ($request->isGet()) {
15133 stevensc 346 
 
14989 efrain 347 
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
348 
            $competencyType = $competencyTypeMapper->fetchOne($competency->competency_type_id);
15133 stevensc 349 
 
14989 efrain 350 
            $competencyBehaviorMapper = CompetencyBehaviorMapper::getInstance($this->adapter);
15133 stevensc 351 
 
14989 efrain 352 
            $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
15133 stevensc 353 
 
15369 efrain 354 
            if($currentCompany) {
15133 stevensc 355 
 
15369 efrain 356 
                $records = $behaviorMapper->fetchAllActiveByCompanyId($currentCompany->id);
357 
            } else {
358 
                $records = $behaviorMapper->fetchAllActiveByDefault();
359 
            }
360 
 
361 
 
14989 efrain 362 
            $behaviors = [];
15133 stevensc 363 
            foreach($records as $record)
364 
            {
14989 efrain 365 
                $competencyBehavior = $competencyBehaviorMapper->fetchOneByBehaviorIdAndCompetencyId($record->id, $competency->id);
15133 stevensc 366 
 
367 
 
14989 efrain 368 
                array_push($behaviors, [
369 
                    'id' => $record->uuid,
370 
                    'description' => $record->description,
371 
                    'checked' => $competencyBehavior ? 1 : 0
15133 stevensc 372 
 
14989 efrain 373 
                ]);
15133 stevensc 374 
 
14989 efrain 375 
            }
15133 stevensc 376 
 
14989 efrain 377 
            $response = [
378 
                'success' => true,
15133 stevensc 379 
                'data' =>[
14989 efrain 380 
                    'competency_type_id' => $competencyType->uuid,
381 
                    'name' => $competency->name,
382 
                    'description' => $competency->description,
383 
                    'status' => $competency->status,
384 
                    'behaviors' =>  $behaviors,
15133 stevensc 385 
               ]
14989 efrain 386 
            ];
1098 geraldo 387 
 
14989 efrain 388 
 
389 
            return new JsonModel($response);
15133 stevensc 390 
        }
391 
        else  if ($request->isPost()) {
1098 geraldo 392 
            if ($currentCompany) {
66 efrain 393 
                $form = new CompetencyForm($this->adapter, $currentCompany->id);
394 
            } else {
395 
                $form = new CompetencyForm($this->adapter);
396 
            }
1 www 397 
            $dataPost = $request->getPost()->toArray();
1098 geraldo 398 
 
399 
 
1 www 400 
            $form->setData($dataPost);
1098 geraldo 401 
 
402 
            if ($form->isValid()) {
1 www 403 
                $dataPost = (array) $form->getData();
14989 efrain 404 
                $dataPost['status'] = empty($dataPost['status']) ? Competency::STATUS_INACTIVE : $dataPost['status'];
1098 geraldo 405 
 
14989 efrain 406 
                $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
407 
                $competencyType = $competencyTypeMapper->fetchOneByUuid($dataPost['competency_type_id']);
408 
                $dataPost['competency_type_id'] = $competencyType->id;
1098 geraldo 409 
 
1 www 410 
                $hydrator = new ObjectPropertyHydrator();
14989 efrain 411 
                $hydrator->hydrate($dataPost, $competency);
28 efrain 412 
 
14989 efrain 413 
                $result = $competencyMapper->update($competency);
1098 geraldo 414 
 
415 
                if ($result) {
1151 geraldo 416 
 
14989 efrain 417 
                    $competencyBehaviorMapper = CompetencyBehaviorMapper::getInstance($this->adapter);
1320 efrain 418 
                    $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
1147 geraldo 419 
 
14989 efrain 420 
                    $competencyBehaviorMapper->deleteAllBCompetencyId($competency->id);
1144 geraldo 421 
 
14989 efrain 422 
                    $behavior_ids = $dataPost['behavior_id'];
15133 stevensc 423 
 
14989 efrain 424 
                    foreach ($behavior_ids as $behavior_id) {
425 
                        $behavior = $behaviorMapper->fetchOneByUuid($behavior_id);
1147 geraldo 426 
                        if ($behavior) {
14989 efrain 427 
                            $behaviorCompetency = new CompetencyBehavior();
428 
                            $behaviorCompetency->competency_id = $competency->id;
1151 geraldo 429 
                            $behaviorCompetency->behavior_id = $behavior->id;
14989 efrain 430 
                            $competencyBehaviorMapper->insert($behaviorCompetency);
1147 geraldo 431 
                        }
1144 geraldo 432 
                    }
1151 geraldo 433 
 
14989 efrain 434 
                    $this->logger->info('Se actualizo la competencia ' . $competencyType->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
1098 geraldo 435 
 
1 www 436 
                    $data = [
437 
                        'success' => true,
438 
                        'data' => 'LABEL_RECORD_UPDATED'
439 
                    ];
440 
                } else {
441 
                    $data = [
1098 geraldo 442 
                        'success' => false,
14989 efrain 443 
                        'data' => $competencyMapper->getError()
1 www 444 
                    ];
445 
                }
1098 geraldo 446 
 
1 www 447 
                return new JsonModel($data);
448 
            } else {
449 
                $messages = [];
450 
                $form_messages = (array) $form->getMessages();
1098 geraldo 451 
                foreach ($form_messages as $fieldname => $field_messages) {
1 www 452 
                    $messages[$fieldname] = array_values($field_messages);
453 
                }
1098 geraldo 454 
 
1 www 455 
                return new JsonModel([
1098 geraldo 456 
                    'success' => false,
457 
                    'data' => $messages
1 www 458 
                ]);
459 
            }
460 
        } else {
461 
            $data = [
462 
                'success' => false,
463 
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
464 
            ];
1098 geraldo 465 
 
1 www 466 
            return new JsonModel($data);
467 
        }
1098 geraldo 468 
 
1 www 469 
        return new JsonModel($data);
470 
    }
1098 geraldo 471 
 
15133 stevensc 472 
    public function deleteAction() {
1 www 473 
        $currentUserPlugin = $this->plugin('currentUserPlugin');
474 
        $currentUser = $currentUserPlugin->getUser();
28 efrain 475 
        $currentCompany = $currentUserPlugin->getCompany();
1098 geraldo 476 
 
1 www 477 
        $request = $this->getRequest();
478 
        $uuid = $this->params()->fromRoute('id');
1098 geraldo 479 
 
480 
        if (!$uuid) {
1 www 481 
            $data = [
1098 geraldo 482 
                'success' => false,
483 
                'data' => 'ERROR_INVALID_PARAMETER'
1 www 484 
            ];
1098 geraldo 485 
 
1 www 486 
            return new JsonModel($data);
487 
        }
1098 geraldo 488 
 
489 
 
14989 efrain 490 
        $competencyMapper = CompetencyMapper::getInstance($this->adapter);
491 
        $competency = $competencyMapper->fetchOneByUuid($uuid);
492 
        if (!$competency) {
1 www 493 
            $data = [
1098 geraldo 494 
                'success' => false,
495 
                'data' => 'ERROR_RECORD_NOT_FOUND'
1 www 496 
            ];
1098 geraldo 497 
 
1 www 498 
            return new JsonModel($data);
499 
        }
1098 geraldo 500 
 
501 
        if ($currentCompany) {
14989 efrain 502 
            if ($competency->company_id != $currentCompany->id) {
28 efrain 503 
                $data = [
1098 geraldo 504 
                    'success' => false,
505 
                    'data' => 'ERROR_UNAUTHORIZED'
28 efrain 506 
                ];
1098 geraldo 507 
 
28 efrain 508 
                return new JsonModel($data);
509 
            }
510 
        } else {
14989 efrain 511 
            if ($competency->company_id) {
28 efrain 512 
                $data = [
1098 geraldo 513 
                    'success' => false,
514 
                    'data' => 'ERROR_UNAUTHORIZED'
28 efrain 515 
                ];
1098 geraldo 516 
 
28 efrain 517 
                return new JsonModel($data);
518 
            }
519 
        }
1098 geraldo 520 
 
521 
        if ($request->isPost()) {
14989 efrain 522 
            $result = $competencyMapper->delete($competency);
1098 geraldo 523 
            if ($result) {
14989 efrain 524 
                $this->logger->info('Se borro la competencia ' . $competency->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
1098 geraldo 525 
 
1 www 526 
                $data = [
527 
                    'success' => true,
528 
                    'data' => 'LABEL_RECORD_DELETED'
529 
                ];
530 
            } else {
531 
 
532 
                $data = [
1098 geraldo 533 
                    'success' => false,
14989 efrain 534 
                    'data' => $competencyMapper->getError()
1 www 535 
                ];
536 
 
537 
                return new JsonModel($data);
538 
            }
539 
        } else {
540 
            $data = [
541 
                'success' => false,
542 
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
543 
            ];
1098 geraldo 544 
 
1 www 545 
            return new JsonModel($data);
546 
        }
1098 geraldo 547 
 
1 www 548 
        return new JsonModel($data);
549 
    }
1098 geraldo 550 
 
15133 stevensc 551 
    public function importAction() {
28 efrain 552 
        $currentUserPlugin = $this->plugin('currentUserPlugin');
553 
        $currentUser = $currentUserPlugin->getUser();
554 
        $currentCompany = $currentUserPlugin->getCompany();
1098 geraldo 555 
 
556 
        if (!$currentCompany) {
28 efrain 557 
            $data = [
558 
                'success' => false,
559 
                'data' => 'ERROR_UNAUTHORIZED'
560 
            ];
1098 geraldo 561 
 
28 efrain 562 
            return new JsonModel($data);
563 
        }
1098 geraldo 564 
 
28 efrain 565 
        $request = $this->getRequest();
1098 geraldo 566 
 
567 
        if ($request->isPost()) {
568 
 
28 efrain 569 
            $competencyTypeMapper = CompetencyTypeMapper::getInstance($this->adapter);
14989 efrain 570 
            $competencyMapper = CompetencyMapper::getInstance($this->adapter);
571 
            $competenciesDefault = $competencyMapper->fetchAllByDefault();
1098 geraldo 572 
 
28 efrain 573 
            $new_records = 0;
1098 geraldo 574 
            foreach ($competenciesDefault as $competencyDefault) {
28 efrain 575 
 
1098 geraldo 576 
                if ($competencyDefault->status == Competency::STATUS_INACTIVE) {
28 efrain 577 
                    continue;
578 
                }
1098 geraldo 579 
 
14989 efrain 580 
                $competency = $competencyMapper->fetchOneByCompanyIdAndCompetencyIdDefault($currentCompany->id, $competencyDefault->id);
1098 geraldo 581 
                if (!$competency) {
582 
 
583 
 
28 efrain 584 
                    $competencyType = $competencyTypeMapper->fetchOneByCompanyId($currentCompany->id, $competencyDefault->competency_type_id);
1098 geraldo 585 
                    if (!$competencyType) {
586 
 
587 
 
28 efrain 588 
                        $competencyTypeDefault = $competencyTypeMapper->fetchOne($competencyDefault->competency_type_id);
1098 geraldo 589 
                        if (!$competencyTypeDefault) {
28 efrain 590 
                            continue;
591 
                        }
1098 geraldo 592 
 
28 efrain 593 
                        $competencyType = new CompetencyType();
594 
                        $competencyType->company_id = $currentCompany->id;
595 
                        $competencyType->competency_type_id_default = $competencyTypeDefault->id;
596 
                        $competencyType->description = $competencyTypeDefault->description;
597 
                        $competencyType->name = $competencyTypeDefault->name;
598 
                        $competencyType->status = CompetencyType::STATUS_ACTIVE;
1098 geraldo 599 
 
600 
 
601 
                        if (!$competencyTypeMapper->insert($competencyType)) {
602 
 
28 efrain 603 
                            $data = [
604 
                                'success' => false,
605 
                                'data' => 'ERROR_CANT_ADD_COMPETENCY_TYPE'
606 
                            ];
1098 geraldo 607 
 
28 efrain 608 
                            return new JsonModel($data);
1098 geraldo 609 
                        }
28 efrain 610 
                    }
1098 geraldo 611 
 
612 
 
28 efrain 613 
                    $competency = new Competency();
614 
                    $competency->competency_id_default = $competencyDefault->id;
615 
                    $competency->company_id = $currentCompany->id;
616 
                    $competency->competency_type_id = $competencyType->id;
617 
                    $competency->description = $competencyDefault->description;
618 
                    $competency->name = $competencyDefault->name;
619 
                    $competency->status = Competency::STATUS_ACTIVE;
1098 geraldo 620 
 
5450 efrain 621 
                    $behaviorMapper = BehaviorMapper::getInstance($this->adapter);
14989 efrain 622 
                    $competencyBehaviorMapper = CompetencyBehaviorMapper::getInstance($this->adapter);
15030 efrain 623 
                    $competencyBehaviors = $competencyBehaviorMapper->fetchAllByCompetencyId($competency->id);
1154 geraldo 624 
 
14989 efrain 625 
                    foreach ($competencyBehaviors as $record) {
1152 geraldo 626 
                        $behavior = $behaviorMapper->fetchOne($record->behavior_id);
1098 geraldo 627 
 
1152 geraldo 628 
                        $behavior = $behaviorMapper->fetchOneByCompanyIdAndBehaviorIdDefault($currentCompany->id, $record->behavior_id);
629 
                        if ($behavior) {
14989 efrain 630 
                            $behaviorCompetency = new CompetencyBehavior();
1152 geraldo 631 
                            $behaviorCompetency->competency_id = $competency->id;
632 
                            $behaviorCompetency->behavior_id = $behavior->id;
14989 efrain 633 
                            $competencyBehaviorMapper->insert($behaviorCompetency);
1152 geraldo 634 
                        }
635 
                    }
1098 geraldo 636 
 
1152 geraldo 637 
 
638 
 
14989 efrain 639 
                    if ($competencyMapper->insert($competency)) {
28 efrain 640 
                        $new_records++;
641 
                    } else {
642 
                        $data = [
643 
                            'success' => false,
15355 efrain 644 
                            'data' => $competencyMapper->getError()
28 efrain 645 
                        ];
1098 geraldo 646 
 
28 efrain 647 
                        return new JsonModel($data);
648 
                    }
649 
                }
650 
            }
1098 geraldo 651 
 
652 
            if ($new_records) {
653 
 
654 
                if (1 == $new_records) {
28 efrain 655 
                    $data = [
656 
                        'success' => true,
657 
                        'data' => 'LABEL_1_COMPETENCY_IMPORTED'
658 
                    ];
1098 geraldo 659 
 
28 efrain 660 
                    return new JsonModel($data);
661 
                } else {
662 
                    $data = [
663 
                        'success' => true,
1098 geraldo 664 
                        'data' => $new_records . ' LABEL_MULTI_COMPETENCIES_IMPORTED'
28 efrain 665 
                    ];
1098 geraldo 666 
 
28 efrain 667 
                    return new JsonModel($data);
668 
                }
669 
            } else {
670 
                $data = [
671 
                    'success' => true,
672 
                    'data' => 'LABEL_NO_COMPETENCY_IMPORTED'
673 
                ];
1098 geraldo 674 
 
28 efrain 675 
                return new JsonModel($data);
676 
            }
677 
        } else {
678 
            $data = [
679 
                'success' => false,
680 
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
681 
            ];
1098 geraldo 682 
 
28 efrain 683 
            return new JsonModel($data);
684 
        }
1098 geraldo 685 
 
28 efrain 686 
        return new JsonModel($data);
687 
    }
15133 stevensc 688 
 
689 
 
690 
 
1 www 691 
}