Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 898 | Rev 1140 | Ir a la última revisión | Mostrar el archivo completo | | | Autoría | Ultima modificación | Ver Log |

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