Proyectos de Subversion LeadersLinked - Backend

<?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 LeadersLinked\Library\Functions;

use LeadersLinked\Mapper\CompanyMapper;

use LeadersLinked\Model\Company;

use LeadersLinked\Mapper\ServiceMapper;

use LeadersLinked\Mapper\CompanyServiceMapper;

use LeadersLinked\Mapper\RoleMapper;

use LeadersLinked\Mapper\CompanyRoleMapper;

use LeadersLinked\Mapper\CompanyUserMapper;

use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Model\CompanyService;

use LeadersLinked\Mapper\CompanyUserRoleMapper;

use LeadersLinked\Model\Role;

use LeadersLinked\Model\CompanyRole;

use LeadersLinked\Model\CompanyUserRole;

use LeadersLinked\Model\CompanyUser;

use Google\Service\Directory\UserMakeAdmin;

use LeadersLinked\Mapper\NetworkMapper;

use LeadersLinked\Model\Service;

class CompanyController 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');

        $currentUser    = $currentUserPlugin->getUser();

        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');

        $network = $currentNetworkPlugin->getNetwork();

        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) {

                $acl = $this->getEvent()->getViewModel()->getVariable('acl');

                $allowServices = $acl->isAllowed($currentUser->usertype_id, 'companies/services');

                $allowRoles = $acl->isAllowed($currentUser->usertype_id, 'companies/roles');

                $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'companies/edit');

                $serviceMapper = ServiceMapper::getInstance($this->adapter);

                $records = $serviceMapper->fetchAll();

                $services = [];

                foreach($records as $record)

                {

                    $services[ $record->id ] = $record->name;

                }

                $roleMapper = RoleMapper::getInstance($this->adapter);

                $records = $roleMapper->fetchAll();

                $roles = [];

                foreach($records as $record)

                {

                    $roles[ $record->id ] = $record->name;

                }

                $networkMapper = NetworkMapper::getInstance($this->adapter);

                $records = $networkMapper->fetchAll();

                $networks = [];

                foreach($records as $record)

                {

                    $networks[ $record->id ] = $record;

                }

                $search = $this->params()->fromQuery('search', []);

                $search = empty($search['value']) ? '' :  Functions::sanitizeFilterString($search['value']);

                $page               = intval($this->params()->fromQuery('start', 1), 10);

                $records_x_page     = intval($this->params()->fromQuery('length', 10), 10);

                $order =  $this->params()->fromQuery('order', []);

                $order_field        = empty($order[0]['column']) ? 99 :  intval($order[0]['column'], 10);

                $order_direction    = empty($order[0]['dir']) ? 'ASC' : strtoupper(Functions::sanitizeFilterString($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';

                }

                $status = Functions::sanitizeFilterString($this->params()->fromQuery('status'));

                if(!in_array($status, [

                    Company::STATUS_ACTIVE,

                    Company::STATUS_DELETED,

                    Company::STATUS_INACTIVE,

                    Company::STATUS_PENDING,

                    Company::STATUS_REJECTED

                ])) {

                    $status = '';

                }

                $network_id = Functions::sanitizeFilterString($this->params()->fromQuery('network_id'));

                $network = $networkMapper->fetchOneByUuid($network_id);

                if($network) {

                    $network_id = $network->id;

                } else {

                    $network_id = 0;

                }

                $companyMapper = CompanyMapper::getInstance($this->adapter);

                $paginator = $companyMapper->fetchAllDataTable($search, $status, $network_id, $page,  $records_x_page, $order_field, $order_direction);

                $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);

                $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);

                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

                $userMapper = UserMapper::getInstance($this->adapter);

                $items = [];

                $records = $paginator->getCurrentItems();

                foreach($records as $record)

                {

                    $security = [

                        'first_name' => '',

                        'last_name' => '',

                        'email' => '',

                    ];

                    $companyUser = $companyUserMapper->fetchCreatorByCompanyId($record->id);

                    if($companyUser) {

                        $user = $userMapper->fetchOne($companyUser->user_id);

                        if($user) {

                            $security['first_name'] = $user->first_name;

                            $security['last_name'] = $user->last_name;

                            $security['email'] = $user->email;

                        }

                    }

                    $companyServices = $companyServiceMapper->fetchAllByCompanyId($record->id);

                    $companyRoles = $companyRoleMapper->fetchAllByCompanyId($record->id);

                    $details['services'] = [] ;

                    foreach($companyServices as $companyService)

                    {

                        if($companyService->status == CompanyService::ACTIVE) {

                            array_push($details['services'], $services[$companyService->service_id]);

                        }

                    }

                    $details['roles'] = [] ;

                    foreach($companyRoles as $companyRole)

                    {

                        array_push($details['roles'], $roles[$companyRole->role_id]);

                    }

                    $details['internal'] = $record->internal == Company::INTERNAL_YES ? 'LABEL_YES' : 'LABEL_NO';

                    $link_profile = '';

                    switch($record->status)

                    {

                        case Company::STATUS_PENDING :

                            $details['status'] = 'LABEL_PENDING';

                            break;

                        case Company::STATUS_ACTIVE :

                            $link_profile = 'https://'. $networks[$record->network_id]->main_hostname . '/company/view/' . $record->uuid;

                            $details['status'] = 'LABEL_ACTIVE';

                            break;

                        case Company::STATUS_INACTIVE :

                            $details['status'] = 'LABEL_INACTIVE';

                            break;

                        case Company::STATUS_REJECTED :

                            $details['status'] = 'LABEL_REJECTED';

                            break;

                        case Company::STATUS_DELETED :

                            $details['status'] = 'LABEL_DELETED';

                            break;

                        default :

                            $details['status'] = 'LABEL_UNKNOWN';

                            break;

                    }

                    $item = [

                        'id' => $record->id,

                        'name' => $record->name,

                        'network' => $networks[$record->network_id]->name,

                        'link_profile' => $link_profile,

                        'details' => $details,

                        'security' => $security,

                        'actions' => [

                           'link_services' => $allowServices ? $this->url()->fromRoute('companies/services', ['id' => $record->uuid ]) : '',

                           'link_roles' => $allowRoles ? $this->url()->fromRoute('companies/roles', ['id' => $record->uuid ]) : '',

                           'link_edit' => $allowEdit ? $this->url()->fromRoute('companies/edit', ['id' => $record->uuid ]) : '',

                        ]

                    ];

                    array_push($items, $item);

                }

                return new JsonModel([

                    'success' => true,

                    'data' => [

                        'items' => $items,

                        'total' => $paginator->getTotalItemCount(),

                    ]

                ]);

            } else  {

                $networkMapper = NetworkMapper::getInstance($this->adapter);

                $records = $networkMapper->fetchAll();

                $networks = [];

                foreach($records as $record)

                {

                    $networks[ $record->uuid ] = $record->name;

                }

                $this->layout()->setTemplate('layout/layout-backend');

                $viewModel = new ViewModel();

                $viewModel->setTemplate('leaders-linked/companies/index.phtml');

                $viewModel->setVariables(['networks' => $networks ]);

                return $viewModel ;

            }

        } else {

            return new JsonModel([

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ]);

        }

    }

    public function servicesAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser = $currentUserPlugin->getUser();

        $request = $this->getRequest();

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

        if(!$uuid) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_INVALID_PARAMETER'

            ];

            return new JsonModel($data);

        }

        $companyMapper = CompanyMapper::getInstance($this->adapter);

        $company = $companyMapper->fetchOneByUuid($uuid);

        if(!$company) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_COMPANY_NOT_FOUND'

            ];

            return new JsonModel($data);

        }

        if($request->isPost()) {

            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);

            $serviceMapper = ServiceMapper::getInstance($this->adapter);

            $services = $serviceMapper->fetchAll();

            foreach($services as $service)

            {

                $status     = Functions::sanitizeFilterString($this->params()->fromPost('status' . $service->id));

                $paid_from  = Functions::sanitizeFilterString($this->params()->fromPost('paid_from' . $service->id));

                $paid_to    = Functions::sanitizeFilterString($this->params()->fromPost('paid_to' . $service->id));

                $ok = true;

                switch ($status) {

                    case CompanyService::ACTIVE :

                    case CompanyService::CANCELLED :

                    case CompanyService::SUSPENDED :

                        $dt_paid_from = \DateTime::createFromFormat('d/m/Y', $paid_from);

                        $dt_paid_to = \DateTime::createFromFormat('d/m/Y', $paid_to);

                        if(!$dt_paid_from || !$dt_paid_to) {

                            $ok = false;

                        }  else {

                            if($dt_paid_from->getTimestamp() > $dt_paid_to->getTimestamp()) {

                                $ok = false;

                            } else {

                                $dt_paid_from->setTime(0, 0, 0);

                                $paid_from = $dt_paid_from->format('Y-m-d');

                                $dt_paid_to->setTime(23, 59, 59);

                                $paid_to = $dt_paid_to->format('Y-m-d');

                            }

                        }

                        break;

                    case CompanyService::INACTIVE :

                        $paid_from = null;

                        $paid_to = null;

                        break;

                    default :

                        $ok = false;

                        break;

                }

                if(!$ok) {

                    return new JsonModel([

                        'success' => false,

                        'data' => 'ERROR_PARAMETERS_ARE_INVALID'

                    ]);

                }

                $companyService = $companyServiceMapper->fetchOneByCompanyIdAndServiceId($company->id, $service->id);

                if($companyService) {

                    $companyService->status = $status;

                    $companyService->paid_from = $paid_from;

                    $companyService->paid_to = $paid_to;

                    if(!$companyServiceMapper->update($companyService)) {

                        return new JsonModel([

                            'success' => false,

                            'data' => $companyServiceMapper->getError()

                        ]);

                    }

                } else {

                    $companyService = new CompanyService();

                    $companyService->service_id = $service->id;

                    $companyService->company_id = $company->id;

                    $companyService->status = $status;

                    $companyService->paid_from = $paid_from;

                    $companyService->paid_to = $paid_to;

                    if(!$companyServiceMapper->insert($companyService)) {

                        return new JsonModel([

                            'success' => false,

                            'data' => $companyServiceMapper->getError()

                        ]);

                    }

                }

            }

            $this->logger->info('Se actualizo los servicios de la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

            return new JsonModel([

                'success' => true,

                'data' => 'LABEL_RECORD_UPDATED'

            ]);

        } else if ($request->isGet()) {

            $serviceMapper = ServiceMapper::getInstance($this->adapter);

            $records = $serviceMapper->fetchAll();

            $services = [];

            foreach($records as $record)

            {

                if($company->default_for_network == Company::DEFAULT_FOR_NETWORK_NO) {

                    if($record->default_company_is_required == Service::DEFAULT_COMPANY_IS_REQUIRED_YES) {

                        continue;

                    }

                }

                $services[ $record->id ] = [

                    'id'        => $record->id,

                    'name'      => $record->name,

                    'status'    => '',

                    'paid_from' => '',

                    'paid_to'   => '',

                ];

            }

            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);

            $records = $companyServiceMapper->fetchAllByCompanyId($company->id);

            foreach($records as $record)

            {

                $paid_from = '';

                if($record->paid_from) {

                    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->paid_from);

                    if($dt) {

                        $paid_from = $dt->format('d/m/Y');

                    }

                }

                $paid_to = '';

                if($record->paid_to) {

                    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->paid_to);

                    if($dt) {

                        $paid_to = $dt->format('d/m/Y');

                    }

                }

                $services[ $record->service_id ] ['status']  = $record->status;

                $services[ $record->service_id ] ['paid_from']  = $paid_from;

                $services[ $record->service_id ] ['paid_to']  = $paid_to;

            }

            $data = [

                'success' => true,

                'data' => $services,

            ];

            return new JsonModel($data);

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function rolesAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser = $currentUserPlugin->getUser();

        $request = $this->getRequest();

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

        if(!$uuid) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_INVALID_PARAMETER'

            ];

            return new JsonModel($data);

        }

        $companyMapper = CompanyMapper::getInstance($this->adapter);

        $company = $companyMapper->fetchOneByUuid($uuid);

        if(!$company) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_COMPANY_NOT_FOUND'

            ];

            return new JsonModel($data);

        }

        if($request->isPost()) {

            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);

            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

            $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($this->adapter);

            $roleMapper = RoleMapper::getInstance($this->adapter);

            $roles = $roleMapper->fetchAll();

            foreach($roles as $role)

            {

                $companyRole = $companyRoleMapper->fetchOneByCompanyIdAndRoleId($company->id, $role->id);

                $checked     = filter_var( $this->params()->fromPost('checked' . $role->id), FILTER_SANITIZE_NUMBER_INT);

                if($checked) {

                    if(!$companyRole) {

                        $companyRole = new CompanyRole();

                        $companyRole->company_id = $company->id;

                        $companyRole->role_id = $role->id;

                        if(!$companyRoleMapper->insert($companyRole)) {

                            return new JsonModel([

                                'success' => false,

                                'data' => $companyRoleMapper->getError()

                            ]);

                        }

                    }

                } else {

                    if($companyRole) {

                        $companyUserRoleMapper->deleteByCompanyIdAndRoleId($company->id, $role->id);

                        $companyRoleMapper->deleteByCompanyIdAndRoleId($company->id, $role->id);

                    }

                }

            }

            $this->logger->info('Se actualizo los roles de la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

            return new JsonModel([

                'success' => true,

                'data' => 'LABEL_RECORD_UPDATED'

            ]);

        } else if ($request->isGet()) {

            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);

            $roleMapper = RoleMapper::getInstance($this->adapter);

            $records = $roleMapper->fetchAll();

            $roles = [];

            foreach($records as $record)

            {

                if($record->service_id) {

                    $companyService = $companyServiceMapper->fetchOneByCompanyIdAndServiceId($company->id, $record->service_id);

                    if(!$companyService || $companyService->status == CompanyService::INACTIVE) {

                        continue;

                    }

                }

                $roles[ $record->id ] = [

                   'id' => $record->id,

                   'name' => $record->name,

                   'fixed' => $record->creator == Role::CREATOR_YES ? true : false,

                   'checked' => $record->creator == Role::CREATOR_YES ? true : false,

                ];

            }

            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);

            $records = $companyRoleMapper->fetchAllByCompanyId($company->id);

            foreach($records as $record)

            {

                $roles[ $record->role_id ]['checked'] = true;

            }

            $data = [

                'success' => true,

                'data' => $roles,

            ];

            return new JsonModel($data);

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function editAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser = $currentUserPlugin->getUser();

        $request = $this->getRequest();

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

        if(!$uuid) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_INVALID_PARAMETER'

            ];

            return new JsonModel($data);

        }

        $companyMapper = CompanyMapper::getInstance($this->adapter);

        $company = $companyMapper->fetchOneByUuid($uuid);

        if(!$company) {

            $data = [

                'success'   => false,

                'data'   => 'ERROR_COMPANY_NOT_FOUND'

            ];

            return new JsonModel($data);

        }

        if($request->isPost()) {

            $status = Functions::sanitizeFilterString($this->params()->fromPost('status'));

            $user_uuid = Functions::sanitizeFilterString($this->params()->fromPost('user_uuid'));

            if(!in_array($status, [

                Company::STATUS_ACTIVE,

                Company::STATUS_INACTIVE,

                Company::STATUS_DELETED,

                Company::STATUS_PENDING,

                Company::STATUS_REJECTED,

            ])) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_PARAMETERS_ARE_INVALID'

                ]);

            }

            $userMapper = UserMapper::getInstance($this->adapter);

            $user = $userMapper->fetchOneByUuid($user_uuid);

            if(!$user) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_USER_NOT_FOUND'

                ]);

            }

            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $user->id);

            if(!$companyUser) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_COMPANY_USER_NOT_FOUND'

                ]);

            }

            if($companyUser->status != CompanyUser::STATUS_ACCEPTED && $companyUser->status != CompanyUser::STATUS_ADMIN_WILL_ADD) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_COMPANY_USER_IS_NOT_ACTIVE'

                ]);

            }

            $creator = $companyUserMapper->fetchCreatorByCompanyId($company->id);

            if($creator->user_id != $user->id) {

                $creator->creator = CompanyUser::CREATOR_NO;

                $creator->backend = CompanyUser::BACKEND_NO;

                $companyUserMapper->update($creator);

                $companyUser->creator = CompanyUser::CREATOR_YES;

                $companyUser->backend = CompanyUser::BACKEND_YES;

                $companyUserMapper->update($companyUser);

            }

            $company->status = $status;

            if($companyMapper->update($company)) {

                $this->logger->info('Se edito la empresa ' . $company->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                return new JsonModel([

                    'success' => true,

                    'data' => 'LABEL_RECORD_UPDATED'

                ]);

            }  else {

                return new JsonModel([

                    'success' => false,

                    'data' => $companyMapper->getError(),

                ]);

            }

        } else if ($request->isGet()) {

            $userMapper = UserMapper::getInstance($this->adapter);

            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

            $records = $companyUserMapper->fetchAllByCompanyId($company->id);

            $users = [] ;

            foreach($records as $record)

            {

                if($record->owner == CompanyUser::OWNER_YES) {

                    continue;

                }

                if($record->status != CompanyUser::STATUS_ACCEPTED && $record->status != CompanyUser::STATUS_ADMIN_WILL_ADD) {

                    continue;

                }

                $user = $userMapper->fetchOne($record->user_id);

                array_push($users, [

                    'uuid' => $user->uuid,

                    'name' => trim($user->first_name . ' ' . $user->last_name) . ' (' . $user->email . ')',

                ] );

            }

            usort($users, function($a, $b) {

                return $a['name'] <=> $b['name'];

            });

            $creator = $companyUserMapper->fetchCreatorByCompanyId($company->id);

            if($creator) {

                $userMapper = UserMapper::getInstance($this->adapter);

                $user = $userMapper->fetchOne($creator->user_id);

                if($user) {

                    $creator = $user->uuid;

                } else {

                    $creator = '';

                }

            } else {

                $creator = '';

            }

            $data = [

                'success' => true,

                'data' => [

                    'status' => $company->status,

                    'users' => $users,

                    'creator' => $creator,

                ],

            ];

            return new JsonModel($data);

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

}