Proyectos de Subversion LeadersLinked - Backend

<?php

declare(strict_types=1);

namespace LeadersLinked;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Cache\Storage\Adapter\AbstractAdapter as CacheAdapter;

use Laminas\ModuleManager\ModuleEvent;

use Laminas\ModuleManager\ModuleManager;

use Laminas\Mvc\MvcEvent;

use Laminas\Config\Reader\Ini;

use Laminas\Permissions\Acl\Acl;

use LeadersLinked\Plugin\CurrentNetworkPlugin;

use LeadersLinked\Plugin\CurrentUserPlugin;

use LeadersLinked\Model\Company;

use LeadersLinked\Mapper\UserMapper;

use Laminas\Permissions\Acl\Resource\GenericResource;

use Laminas\Permissions\Acl\Role\GenericRole;

use LeadersLinked\Mapper\CompanyUserMapper;

use LeadersLinked\Mapper\CompanyUserRoleMapper;

use LeadersLinked\Mapper\RoleMapper;

use LeadersLinked\Mapper\CompanyServiceMapper;

use LeadersLinked\Model\Network;

use LeadersLinked\Model\Service;

use LeadersLinked\Model\User;

use LeadersLinked\Model\UserType;

use LeadersLinked\Model\CompanyService;

use LeadersLinked\Model\CompanyUser;

use LeadersLinked\Mapper\CompanyMapper;

use LeadersLinked\Mapper\ApplicationVariantMapper;

class Module

{

    /**

     *

     * @var boolean

     */

    private $isJson;

    /**

     *

     * @var boolean

     */

    private $isHtml;

    /**

     *

     * @var Acl

     */

    private $acl;

    /**

     *

     * @var Company

     */

    private $company;

    /**

     *

     * @var AdapterInterface

     */

    private $adapter;

    /**

     *

     * @var CurrentUserPlugin

     */

    private $currentUserPlugin;

    /**

     *

     * @var CurrentNetworkPlugin

     */

    private $currentNetworkPlugin;

    /**

     *

     * @var array

     */

    private $routesAuthorized = [];

    /**

     *

     * @var boolean

     */

    private $authByHeaders = false;

    public function init(ModuleManager $moduleManager)

    {

        $events = $moduleManager->getEventManager();

        $events->attach(ModuleEvent::EVENT_MERGE_CONFIG, array($this, 'onMergeConfig'));

    }

    public function onMergeConfig(ModuleEvent $event)

    {

        $configListener = $event->getConfigListener();

        $config         = $configListener->getMergedConfig(false);

        $reader = new Ini();

        $data = $reader->fromFile('config/leaderslinked.ini');

        $prefix = 'leaderslinked';

        foreach($data as $section => $pairs)

        {

            foreach($pairs as $key => $value)

            {

                $config[$prefix . '.' . $section . '.' . $key] = $value;

            }

        }

        $configListener->setMergedConfig($config);

    }

    public function getConfig() : array

    {

        return include __DIR__ . '/../config/module.config.php';

    }

    public function onBootstrap(MvcEvent $event)

    {

        $serviceManager = $event->getApplication()->getServiceManager();

        $adapter = $serviceManager->get('leaders-linked-db');

       // $logger          = $serviceManager->get('Zend\Log\Logger');

        $session = $serviceManager->get('leaders-linked-session');

        $session->start();

        $translator = $serviceManager->get('MvcTranslator');

        $translator->addTranslationFile(

            'phpArray',

            __DIR__ . '/i18n/validate.php',

            'default'

            );

        $translator->addTranslationFile(

            'phpArray',

            __DIR__ . '/i18n/spanish.php',

            'default'

            );

        \Laminas\Validator\AbstractValidator::setDefaultTranslator($translator);

        $this->currentNetworkPlugin = new CurrentNetworkPlugin($adapter);

        if(!$this->currentNetworkPlugin->hasNetwork()) {

            header("HTTP/1.1 401 Unauthorized - Private network - not found");

            exit;

        }

        if($this->currentNetworkPlugin->getNetwork()->status == Network::STATUS_INACTIVE) {

            header("HTTP/1.1 401 Unauthorized - Private network - inactive");

            exit;

        }

        if(empty($_SERVER['REDIRECT_URL'])) {

            if(empty($_SERVER['REQUEST_URI'])) {

                $routeName = '';

            } else {

                $routeName = $_SERVER['REQUEST_URI'];

            }

        } else {

            $routeName = $_SERVER['REDIRECT_URL'];

        }

        $routeName = strtolower(trim($routeName));

        if(strlen($routeName) > 0 && substr($routeName, 0, 1) == '/') {

            $routeName = substr($routeName, 1);

        }

        $this->isHtml = $this->isJson ? false : true;

        $this->currentUserPlugin = new CurrentUserPlugin($adapter);

        if($this->currentUserPlugin->hasIdentity()) {

            if(in_array($routeName, ['signout', 'signin-admin', 'signin-company', 'home'])) {

                $checkUserForNetwork = false;

            } else {

                $checkUserForNetwork = true;

            }

        } else {

            $checkUserForNetwork = false;

        }

        if($checkUserForNetwork) {

            if($this->currentUserPlugin->getUser()->network_id != $this->currentNetworkPlugin->getNetworkId()) {

                header("HTTP/1.1 401 Unauthorized - The user is not part of this private network");

                exit;

            }

        }

        $this->initAcl($event);

        $eventManager = $event->getApplication()->getEventManager();

        $eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, [$this,'onDispatchError'], 0);

        $eventManager->attach(MvcEvent::EVENT_RENDER_ERROR, [$this,'onRenderError'], 0);

        $sharedManager = $eventManager->getSharedManager();

        $sharedManager->attach(__NAMESPACE__, MvcEvent::EVENT_DISPATCH, [$this, 'authPreDispatch'], 100);

        $sharedManager->attach(__NAMESPACE__, MvcEvent::EVENT_DISPATCH, [$this, 'authPosDispatch'], -100);

    }

    public function initAcl(MvcEvent $event)

    {

        $serviceManager = $event->getApplication()->getServiceManager();

        $adapter = $serviceManager->get('leaders-linked-db');

        require_once   (dirname(__DIR__) . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR . 'acl.config.php');

        //header('Content-type: text/plain');

        $this->acl = new Acl();

        $resources = getAclResources();

        foreach($resources as $resourceName)

        {

           //echo $resourceName . PHP_EOL;

            $this->acl->addResource(new GenericResource($resourceName));

        }

        $rolesForUsertype = getAclRolesForUsertype();

        $user = $this->currentUserPlugin->getUser();

        $company = $this->currentUserPlugin->getCompany();

        $network = $this->currentNetworkPlugin->getNetwork();

        if($company) {

            $resources = [];

            $this->acl->addRole(new GenericRole($user->usertype_id));

            foreach($rolesForUsertype[UserType::USER] as $resourceName)

            {

                if(!in_array($resourceName, $resources)) {

                    array_push($resources, $resourceName);

                }

            }

            $servicesActive = [];

            $now = date('Y-m-d');

            $companyServiceMapper = CompanyServiceMapper::getInstance($adapter);

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

            foreach($companyServices as $companyService)

            {

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

                    $paid_from = trim(substr($companyService->paid_from, 0, 10));

                    $paid_to = trim(substr($companyService->paid_to, 0, 10));

                    if($now >= $paid_from   && $now <= $paid_to) {

                        if(!in_array($companyService->id, $servicesActive)) {

                            array_push($servicesActive, $companyService->service_id);

                        }

                    }

                }

            }

            $rolesForCompany = getAclRolesCompany();

            $companyUserMapper = CompanyUserMapper::getInstance($adapter);

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

            $roleMapper = RoleMapper::getInstance($adapter);

            if($companyUser) {

                if($companyUser->creator == CompanyUser::CREATOR_YES) {

                    $applicationVariantMapper = ApplicationVariantMapper::getInstance($adapter);

                    $total = $applicationVariantMapper->fetchCountActiveByCompanyId($company->id);

                    if($total > 0) {

                        $resourceNames = getAclPermissionPushTemplatesForCustomApps();

                        foreach($resourceNames as $resourceName)

                        {

                            if(!in_array($resourceName, $resources)) {

                                array_push($resources, $resourceName);

                            }

                        }

                    }

                    $roles = $roleMapper->fetchAllForCreator();

                    if($roles) {

                        foreach($roles as $role)

                        {

                            if(!empty($rolesForCompany[$role->code])) {

                                foreach($rolesForCompany[$role->code] as $resourceName) {

                                    if(!in_array($resourceName, $resources)) {

                                        array_push($resources, $resourceName);

                                    }

                                }

                            }

                        }

                    }

                    foreach ($servicesActive as $service_id) {

                        $roles = $roleMapper->fetchAllByServiceId($service_id);

                        foreach($roles as $role) {

                            if(!empty($rolesForCompany[$role->code])) {

                                foreach($rolesForCompany[$role->code] as $resourceName) {

                                    if(!in_array($resourceName, $resources)) {

                                        array_push($resources, $resourceName);

                                    }

                                }

                            }

                        }

                    }

                } else {

                    $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($adapter);

                    $companyUserRoles = $companyUserRoleMapper->fetchAllByCompanyIdAndUserId($company->id, $user->id);

                    foreach($companyUserRoles as $companyUserRole)

                    {

                         $role = $roleMapper->fetchOne($companyUserRole->role_id);

                         if($role) {

                             if($role->service_id) {

                                 if(!in_array($role->service_id, $servicesActive)) {

                                    continue;

                                 }

                             }

                             if(isset($rolesForCompany[ $role->code ] )) {

                                 foreach($rolesForCompany[ $role->code ] as $resourceName)

                                 {

                                     if(!in_array($resourceName, $resources)) {

                                        array_push($resources, $resourceName);

                                     }

                                 }

                            }

                        }

                    }

                }

            }

            foreach($resources as $resourceName)

            {

                $this->acl->allow($user->usertype_id, $resourceName);

            }

        }   else {

            foreach($rolesForUsertype as $usertype => $resources)

            {

                $this->acl->addRole(new GenericRole($usertype));

                foreach ($resources as $resourceName)

                {

                    // echo $resourceName . PHP_EOL;

                    $this->acl->allow($usertype, $resourceName);

                }

            }

            if($this->currentUserPlugin->hasIdentity()) {

                $user = $this->currentUserPlugin->getUser();

                if($user->is_super_user == User::IS_SUPER_USER_YES) {

                    $resources = getAclPermissionSuperAdmin();

                    foreach ($resources as $resourceName)

                    {

                        $this->acl->allow(UserType::ADMIN, $resourceName);

                    }

                }

            }

            if($this->company == null) {

                if($network->default == Network::DEFAULT_YES) {

                    $resources = getAclPermissionAdminForDefaultNetwork();

                    foreach ($resources as $resourceName)

                    {

                        $this->acl->allow(UserType::ADMIN, $resourceName);

                    }

                } else {

                    $companyMapper = CompanyMapper::getInstance($adapter);

                    $company = $companyMapper->fetchDefaultForNetworkByNetworkId($network->id);

                    if($company) {

                        $companyUserMapper = CompanyUserMapper::getInstance($adapter);

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

                        if($companyUser && $companyUser->user_id == $this->currentUserPlugin->getUserId()) {

                            $resources = getAclPermissionAdminForNonDefaultNetwork();

                            foreach ($resources as $resourceName)

                            {

                                $this->acl->allow(UserType::ADMIN, $resourceName);

                            }

                        }

                    }

                }

            }

        }

        $event->getViewModel()->setVariable('acl', $this->acl);

    }

    public function onDispatchError(MvcEvent $event)

    {

        $this->processError($event);

    }

    public function onRenderError(MvcEvent $event)

    {

        $this->processError($event);

    }

    public function sendResponse(\Laminas\Http\Response $response, $data)

    {

        if($this->isJson) {

            $headers = $response->getHeaders();

            $headers->clearHeaders();

            $headers->addHeaderLine('Content-type', 'application/json; charset=UTF-8');

            $response->setStatusCode(200);

            $response->setContent(json_encode($data));

            $response->send();

        } else {

           // print_r($data); exit;

            throw new \Exception($data['data']);

        }

        exit;

    }

    public function processError(MvcEvent $event)

    {

        $request =  $event->getRequest();

        if((method_exists($request, 'isXmlHttpRequest') && $request->isXmlHttpRequest()) || ($this->isJson && !$this->isHtml)) {

            $error = $event->getError();

            if (!$error) {

                return;

            }

            $response = $event->getResponse();

            if('error-exception' == $error) {

                $exception = $event->getParam('exception');

                error_log($exception->getCode() . ' ' . $exception->getMessage());

                //error_log($exception->getTraceAsString());

                $data = [

                    'success' => false,

                    'data' => 'An error occurred during execution; please try again later.'

                ];

            } else if('error-router-no-match' == $error) {

                $data = [

                    'success' => false,

                    'data' => 'Resource not found.'

                ];

            } else if(' error-controller-not-found' == $error) {

                $data = [

                    'success' => false,

                    'data' => 'Controller not found.'

                ];

            } else {

                $data = [

                    'success' => false,

                    'data' => 'Unknow error.' , 'error' => $error

                ];

            }

            $this->sendResponse($response, $data);

        }

        $this->initAcl($event);

    }

    public function authPreDispatch(MvcEvent $event)

    {

        $serviceManager = $event->getApplication()->getServiceManager();

        $adapter = $serviceManager->get('leaders-linked-db');

        $userTypeId = $this->currentUserPlugin->getUserTypeId();

        $routeName = $event->getRouteMatch()->getMatchedRouteName();

        if($this->acl->isAllowed($userTypeId, $routeName)) {

            $user = $this->currentUserPlugin->getUser();

            if($user) {

                $updateLastActivity = true;

                if ('chat' == substr($routeName, 0, 4)) {

                    $updateLastActivity = false;

                }

                if ('inmail' == substr($routeName, 0, 6)) {

                    $updateLastActivity = false;

                }

                if ('check-session' == $routeName) {

                    $updateLastActivity = false;

                }

                if($updateLastActivity) {

                    $userMapper = UserMapper::getInstance($adapter);

                    $userMapper->updateLastActivity($user->id);

                }

            }

        } else {

            echo "userTypeId = $userTypeId routeName = $routeName";

            exit;

            $this->currentUserPlugin->clearIdentity();

            if($this->isJson) {

                $response = $event->getResponse();

                $headers = $response->getHeaders();

                $headers->clearHeaders();

                $headers->addHeaderLine('Content-type', 'application/json; charset=UTF-8');

                $response->setStatusCode(200);

                $response->setContent(json_encode(['success' => false, 'data' => 'Unauthorized.', 'fatal' => true]));

                $response->send();

            } else {

                $url = $event->getRouter()->assemble([], ['name' => 'signout']);

                $response = $event->getResponse();

                $headers = $response->getHeaders();

                $headers->clearHeaders();

                $headers->addHeaderLine('Location', $url);

                $response->setStatusCode(302);

                $response->send();

            }

            exit;

        }

    }

    public function authPosDispatch(MvcEvent $event)

    {

    }

}