public function setSessionStorage()
{
$options = new DbTableGatewayOptions();
$options->setDataColumn('session_data')->setIdColumn('session_id')->setLifetimeColumn('life_time')->setModifiedColumn('update_time')->setNameColumn('session_name');
$handler = new DbTableGateway($this->tblgw, $options);
$this->sessionManager = new SessionManager();
$this->sessionManager->setSaveHandler($handler);
if ($this->sessionConfig) {
$options = gv('options', $this->sessionConfig);
$sessionConfig = new \Zend\Session\Config\SessionConfig();
$sessionConfig->setOptions($options);
$this->sessionManager->setConfig($sessionConfig);
}
$this->sessionManager->setSaveHandler($handler);
Container::setDefaultManager($this->sessionManager);
$this->sessionManager->start();
$this->container = new Container('init');
if (!$this->container->init) {
$request = $this->request;
$this->container->init = 1;
$this->container->remoteAddr = $request->getServer()->get('REMOTE_ADDR');
$this->container->httpUserAgent = $request->getServer()->get('HTTP_USER_AGENT');
$this->container->create = time();
}
// update session id
if (SESSION_ID_EXPIRE < time() - $this->container->create) {
$this->sessionManager->regenerateId(true);
$this->container->create = time();
}
return $this->sessionManager;
}
public function onBootstrap(MvcEvent $e)
{
$eventManager = $e->getApplication()->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
// Listeners to ensure that we always send back JSON.
// If we set a 404 in the ViewModel, then the RouteNotFoundStrategy will add it's own
// fields to the ViewModel, so detect a 404 first and respond to it
$eventManager->getSharedManager()->attach('Zend\\Stdlib\\DispatchableInterface', MvcEvent::EVENT_DISPATCH, array($this, 'detect404'), -89);
// Ensure we always render JSON
$eventManager->attach(MvcEvent::EVENT_RENDER, array($this, 'ensureJsonModel'), 999);
// Turn errors into JSON
// $eventManager->attach(MvcEvent::EVENT_RENDER, array($this, 'renderError'));
//*********Session
$sm = $e->getApplication()->getServiceManager();
$config = $sm->get('session_config');
$storage = null;
if ($sm->has('session_storage', false)) {
$storage = $sm->get('session_storage');
}
$saveHandler = null;
if ($sm->has('session_save_handler', false)) {
$saveHandler = $sm->get('session_save_handler');
}
$sessionManager = new SessionManager($config, $storage, $saveHandler);
Container::setDefaultManager($sessionManager);
//$sessionManager->start();
}
public function onBootstrap(EventInterface $e)
{
/** @var \Zend\Mvc\Application $app */
$app = $e->getTarget();
$config = $app->getConfig();
$sessionConfig = new SessionConfig();
if (isset($config['session']['options'])) {
$options = $config['session']['options'];
if (isset($options['cookie_domain']) && strpos($_SERVER['SERVER_NAME'], $options['cookie_domain']) === false) {
$options['cookie_domain'] = $_SERVER['SERVER_NAME'];
}
$sessionConfig->setOptions($options);
}
$serviceManager = $app->getServiceManager();
$storage = null;
$saveHandler = null;
if ($serviceManager->has('Session\\Service\\Storage', false)) {
/** @var \Zend\Session\Storage\StorageInterface $storage */
$storage = $serviceManager->get('Session\\Service\\Storage');
}
if ($serviceManager->has('Session\\Service\\SaveHandler', false)) {
/** @var \Zend\Session\SaveHandler\SaveHandlerInterface $saveHandler */
$saveHandler = $serviceManager->get('Session\\Service\\SaveHandler');
}
Container::setDefaultManager(new SessionManager($sessionConfig, $storage, $saveHandler));
}
public function testCanSetDefaultManagerToNull()
{
$manager = new TestAsset\TestManager();
Container::setDefaultManager($manager);
Container::setDefaultManager(null);
$this->assertNotSame($manager, Container::getDefaultManager());
}
/**
* @param ServiceLocatorInterface $sm
* @return SessionManager
*/
public function createService(ServiceLocatorInterface $sm)
{
$config = $sm->get('config');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session['config'])) {
$class = isset($session['config']['class']) ? $session['config']['class'] : 'Zend\\Session\\Config\\SessionConfig';
$options = isset($session['config']['options']) ? $session['config']['options'] : array();
$sessionConfig = new $class();
$sessionConfig->setOptions($options);
}
$sessionStorage = null;
if (isset($session['storage'])) {
$class = $session['storage'];
$sessionStorage = new $class();
}
$sessionSaveHandler = null;
if (isset($session['save_handler'])) {
$sessionSaveHandler = $sm->get($session['save_handler']);
}
$sessionManager = new SessionManager($sessionConfig, $sessionStorage, $sessionSaveHandler);
} else {
$sessionManager = new SessionManager();
}
Container::setDefaultManager($sessionManager);
return $sessionManager;
}
public function getServiceConfig()
{
return array('abstract_factories' => array('Zend\\Cache\\Service\\StorageCacheAbstractServiceFactory', 'Zend\\Log\\LoggerAbstractServiceFactory'), 'factories' => array('translator' => 'Zend\\Mvc\\Service\\TranslatorServiceFactory', 'Application\\SessionManager' => function ($sm) {
$config = $sm->get('Config');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session)) {
$sessionConfig = new \Zend\Session\Config\SessionConfig();
$sessionConfig->setOptions($session);
}
$storagePath = '';
if (isset($config['app_base_dir'])) {
$storagePath = $config['app_base_dir'] . DIRECTORY_SEPARATOR;
}
$storagePath .= '/data/sessions/cache';
$fileCacheStorage = new \Zend\Cache\Storage\Adapter\FileSystem(['cache_dir' => $storagePath]);
$sessionSaveHandler = new \Zend\Session\SaveHandler\Cache($fileCacheStorage);
$sessionManager = new \Zend\Session\SessionManager($sessionConfig, null, $sessionSaveHandler);
if (isset($session['validators'])) {
$chain = $sessionManager->getValidatorChain();
foreach ($session['validators'] as $validator) {
$validator = new $validator();
$chain->attach('session.validate', array($validator, 'isValid'));
}
}
} else {
$sessionManager = new \Zend\Session\SessionManager();
}
\Zend\Session\Container::setDefaultManager($sessionManager);
return $sessionManager;
}));
}
public function __invoke(ContainerInterface $container)
{
$manager = new SessionManager();
Container::setDefaultManager($manager);
$realSessionContainer = new Container('zend_expressive');
return new SessionContainer($realSessionContainer);
}
public function createService(\Zend\ServiceManager\ServiceLocatorInterface $sm)
{
$config = $sm->get('config');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session['config'])) {
$class = isset($session['config']['class']) ? $session['config']['class'] : 'Zend\\Session\\Config\\SessionConfig';
$options = isset($session['config']['options']) ? $session['config']['options'] : array();
$sessionConfig = new $class();
$sessionConfig->setOptions($options);
}
$sessionStorage = null;
if (isset($session['storage'])) {
$class = $session['storage'];
$sessionStorage = new $class();
}
$sessionSaveHandler = null;
if (isset($session['save_handler'])) {
// class should be fetched from service manager since it will require constructor arguments
$sessionSaveHandler = $sm->get($session['save_handler']);
}
$sessionManager = new self($sessionConfig, $sessionStorage, $sessionSaveHandler);
} else {
$sessionManager = new self();
}
\Zend\Session\Container::setDefaultManager($sessionManager);
return $sessionManager;
}
public function initSession($config)
{
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions($config);
$sessionManager = new SessionManager($sessionConfig);
$sessionManager->start();
Container::setDefaultManager($sessionManager);
}
public function sessionStart(MvcEvent $event)
{
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions(array());
$sessionManager = new SessionManager($sessionConfig);
$sessionManager->start();
Container::setDefaultManager($sessionManager);
}
public function bootstrapSession($e)
{
$sessionManager = $e->getApplication()->getServiceManager()->get('Zend\\Session\\SessionManager');
// TODO start session if session cookie exists?
//$session->start();
// ensure this session manager is used by default
Container::setDefaultManager($sessionManager);
}
public function tearDown()
{
$ref = new \ReflectionClass('Zend\\Validator\\Csrf');
$hashCache = $ref->getProperty('hashCache');
$hashCache->setAccessible(true);
$hashCache->setValue(new Csrf(), array());
SessionContainer::setDefaultManager(null);
}
public function __invoke(ContainerInterface $container)
{
/** @var SessionManager $manager */
$manager = $container->get(SessionManager::class);
SessionContainer::setDefaultManager($manager);
$manager->start();
return new SessionMiddleware();
}
/**
* @return void
*/
private function init()
{
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions($this->config);
$sessionManager = new SessionManager($sessionConfig);
$sessionManager->start();
Container::setDefaultManager($sessionManager);
}
public function getServiceConfig()
{
return array('factories' => array('JYLibrary\\Model\\SessionTable' => function ($sm) {
$dbAdapter = $sm->get('Zend\\Db\\Adapter\\Adapter');
$table = new SessionTable($dbAdapter);
return $table;
}, 'Zend\\Session\\SessionManager' => function ($sm) {
$config = $sm->get('config');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session['config'])) {
$class = isset($session['config']['class']) ? $session['config']['class'] : 'Zend\\Session\\Config\\SessionConfig';
$options = isset($session['config']['options']) ? $session['config']['options'] : array();
$sessionConfig = new $class();
$sessionConfig->setOptions($options);
}
$sessionStorage = null;
if (isset($session['storage'])) {
$class = $session['storage'];
$sessionStorage = new $class();
}
$sessionSaveHandler = null;
if (isset($session['save_handler'])) {
// class should be fetched from service manager since it will require constructor arguments
$sessionSaveHandler = $sm->get($session['save_handler']);
}
$sessionManager = new SessionManager($sessionConfig, $sessionStorage, $sessionSaveHandler);
if (isset($session['validator'])) {
$chain = $sessionManager->getValidatorChain();
foreach ($session['validator'] as $validator) {
$validator = new $validator();
$chain->attach('session.validate', array($validator, 'isValid'));
}
}
} else {
$sessionManager = new SessionManager();
/*
$adapter = new \Zend\Db\Adapter\Adapter(array(
'driver' => 'Mysqli',
'database' => 'jymobile',
'username' => 'root',
'password' => '',
'hostname'=>'localhost'
));
$tableGateway = new TableGateway('session', $adapter);
$saveHandler = new DbTableGateway($tableGateway, new DbTableGatewayOptions());
$manager = new SessionManager();
$manager->setSaveHandler($saveHandler);
//echo '×Ô¶¨ÒåsessionManager';
*/
}
Container::setDefaultManager($sessionManager);
return $sessionManager;
}));
}
public function onBootstrap(MvcEvent $e)
{
$eventManager = $e->getApplication()->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
$sess = new SessionManager();
$sess->start();
Container::setDefaultManager($sess);
}
/**
* createService
*
* Create the session manager configuration service.
*
* @param ServiceLocatorInterface $serviceManager The service manager instance.
*
* @return SessionManager
*/
public function createService(ServiceLocatorInterface $serviceManager)
{
$options = $this->getOptions($serviceManager);
$sessionManager = new SessionManager($this->getSessionConfiguration($serviceManager, $options), $this->getSessionStorage($serviceManager, $options), $this->getSessionSaveHandler($serviceManager, $options), isset($options['validators']) ? $options['validators'] : []);
if (isset($options['default_session_manager']) && $options['default_session_manager']) {
Container::setDefaultManager($sessionManager);
}
return $sessionManager;
}
public function onBootstrap(\Zend\EventManager\EventInterface $e)
{
$config = $e->getApplication()->getServiceManager()->get('Configuration');
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions($config['session']);
$sessionManager = new SessionManager($sessionConfig, null, null);
Container::setDefaultManager($sessionManager);
$sessionManager->start();
}
public function setUp()
{
$this->_server = new Amf\Server();
$this->_server->setProduction(false);
Parser\TypeLoader::resetMap();
Session\Container::setDefaultManager(null);
$this->session = new \ZendTest\Session\TestAsset\TestManager(array('class' => 'Zend\\Session\\Configuration\\StandardConfiguration', 'storage' => 'Zend\\Session\\Storage\\ArrayStorage'));
Session\Container::setDefaultManager($this->session);
}
public function createService(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->get('config');
$request = $serviceLocator->get('request');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session['config'])) {
$class = isset($session['config']['class']) ? $session['config']['class'] : '\\Zend\\Session\\Config\\SessionConfig';
$options = isset($session['config']['options']) ? $session['config']['options'] : array();
$sessionConfig = new $class();
$sessionConfig->setOptions($options);
}
$sessionStorage = null;
if (isset($session['storage'])) {
$class = $session['storage'];
$sessionStorage = new $class();
}
$sessionSaveHandler = null;
if (isset($session['savehandler'])) {
/**
* getting session save handler from service manager,
* session save handler service name is configured on global config
*/
$sessionSaveHandler = $serviceLocator->get($session['savehandler']['database']['savehandler']);
}
$sessionManager = new \Zend\Session\SessionManager($sessionConfig, $sessionStorage, $sessionSaveHandler);
$sessionManager->start();
$metaData = $sessionManager->getStorage()->getMetadata();
if (empty($sessionManager->getStorage()->getMetadata('_VALID'))) {
if (isset($config['session']['validators'])) {
$chain = $sessionManager->getValidatorChain();
foreach ($config['session']['validators'] as $validator) {
switch ($validator) {
case 'Zend\\Session\\Validator\\HttpUserAgent':
$validator = new $validator($request->getServer()->get('HTTP_USER_AGENT'));
break;
case 'Zend\\Session\\Validator\\RemoteAddr':
$validator = new $validator($request->getServer()->get('REMOTE_ADDR'));
break;
default:
$validator = new $validator();
}
$chain->attach('session.validate', array($validator, 'isValid'));
}
}
} else {
}
} else {
$sessionManager = new \Zend\Session\SessionManager();
}
\Zend\Session\Container::setDefaultManager($sessionManager);
$sessionManager->start();
return $sessionManager;
}
/**
COPY DARI SIMBRA :D
**/
public function getServiceConfig()
{
return array('factories' => array('Fauth\\Model\\User' => function ($sm) {
$adapter = $sm->get('TNDE\\DbAdapter');
$table = new UserDbTable($adapter);
return $table;
}, 'Zend\\Session\\SessionManager' => function ($sm) {
$config = $sm->get('config');
if (isset($config['session'])) {
$session = $config['session'];
$sessionConfig = null;
if (isset($session['config'])) {
$class = isset($session['config']['class']) ? $session['config']['class'] : 'Zend\\Session\\Config\\SessionConfig';
$options = isset($session['config']['options']) ? $session['config']['options'] : array();
$sessionConfig = new $class();
$sessionConfig->setOptions($options);
}
$sessionStorage = null;
if (isset($session['storage'])) {
$class = $session['storage'];
$sessionStorage = new $class();
}
$sessionSaveHandler = null;
if (isset($session['save_handler'])) {
// class should be fetched from service manager since it will require constructor arguments
$sessionSaveHandler = $sm->get($session['save_handler']);
}
$sessionManager = new SessionManager($sessionConfig, $sessionStorage, $sessionSaveHandler);
if (isset($session['validator'])) {
$chain = $sessionManager->getValidatorChain();
foreach ($session['validator'] as $validator) {
$validator = new $validator();
$chain->attach('session.validate', array($validator, 'isValid'));
}
}
} else {
$sessionManager = new SessionManager();
}
Container::setDefaultManager($sessionManager);
return $sessionManager;
}, 'Fauth\\sessionContainer' => function ($sm) {
$container = new Container('container');
if (!isset($container->init)) {
$session = $sm->get('Zend\\Session\\SessionManager');
$session->regenerateId(true);
$container->init = 1;
}
return $container;
}, 'Fauth\\authService' => function ($sm) {
$container = $sm->get('Fauth\\sessionContainer');
$authService = new AuthService($container);
return $authService;
}));
}
public function getSessionManager()
{
$sessionManager = new ZendSessionManager($this->getConfigObject(), $this->getStorageObject(), $this->getSessionSaveHandler());
$chain = $sessionManager->getValidatorChain();
foreach ($this->getSessionOptions()->getValidators() as $validatorName) {
$validator = $this->validatorPluginManager->get($validatorName);
$chain->attach('session.validate', array($validator, 'isValid'));
}
SessionContainer::setDefaultManager($sessionManager);
return $sessionManager;
}
public function onBootstrap(MvcEvent $e)
{
/* @var $sm \Zend\ServiceManager\ServiceManager */
$sm = $e->getApplication()->getServiceManager();
$config = $sm->get('Config');
// bootstrap session
$tableGateway = new TableGateway($config['app']['session.tableName'], $sm->get('dbAdapter'));
$saveHandler = new DbTableGateway($tableGateway, new DbTableGatewayOptions());
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions($config['session']);
$sessionManager = new SessionManager($sessionConfig);
$sessionManager->setSaveHandler($saveHandler);
$sessionManager->start();
Container::setDefaultManager($sessionManager);
// translate
$sm->get('translator');
$eventManager = $e->getApplication()->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
// bootstrap locale
// $headers = $app->getRequest()->getHeaders();
// Locale::setDefault($config['locale']['default']);
// if($headers->has('Accept-Language')) {
// $locales = $headers->get('Accept-Language')->getPrioritized();
// // Loop through all locales, highest priority first
// foreach($locales as $locale) {
// if(!!($match = Locale::lookup($config['locale']['supported'], $locale->typeString))) {
// // The locale is one of our supported list
// Locale::setDefault($match);
// break;
// }
// }
// if(!$match) {
// // Nothing from the supported list is a match
// Locale::setDefault($config['locale']['default']);
// }
// }
// switch layout
$e->getApplication()->getEventManager()->getSharedManager()->attach('Zend\\Mvc\\Controller\\AbstractActionController', 'dispatch', function ($e) {
$controller = $e->getTarget();
$controllerClass = get_class($controller);
$moduleNamespace = substr($controllerClass, 0, strpos($controllerClass, '\\'));
$config = $e->getApplication()->getServiceManager()->get('config');
$routeMatch = $e->getRouteMatch();
$actionName = strtolower($routeMatch->getParam('action', 'not-found'));
// get the action name
if (isset($config['module_layouts'][$moduleNamespace][$actionName])) {
$controller->layout($config['module_layouts'][$moduleNamespace][$actionName]);
} elseif (isset($config['module_layouts'][$moduleNamespace]['default'])) {
$controller->layout($config['module_layouts'][$moduleNamespace]['default']);
}
}, 100);
}
public function initSession($config, \Zend\ServiceManager\ServiceManager $sm)
{
$sessionConfig = new SessionConfig();
$sessionConfig->setOptions($config);
$sessionManager = new SessionManager($sessionConfig);
$sessionManager->getValidatorChain()->attach('session.validate', array(new HttpUserAgent(), 'isValid'));
$sessionManager->getValidatorChain()->attach('session.validate', array(new RemoteAddr(), 'isValid'));
$dbAdapter = $sm->get('Zend\\Db\\Adapter\\Adapter');
$tableGateway = new TableGateway(new TableIdentifier('sessions', 'users'), $dbAdapter);
$saveHandler = new DbTableGateway($tableGateway, new DbTableGatewayOptions());
$sessionManager->setSaveHandler($saveHandler);
$sessionManager->start();
Container::setDefaultManager($sessionManager);
}
/**
* Get CSRF validator
*
* @return \Zend\Validator\Csrf
*/
public function getCsrfValidator()
{
if (null === $this->csrfValidator) {
$serviceLocator = $this->getServiceLocator();
if ($serviceLocator && $serviceLocator->has('Zend\\Session\\ManagerInterface')) {
$defaultManager = SessionContainer::getDefaultManager();
$serviceManager = $serviceLocator->get('Zend\\Session\\ManagerInterface');
if ($defaultManager !== $serviceManager) {
SessionContainer::setDefaultManager($serviceManager);
}
}
}
return parent::getCsrfValidator();
}
/**
* {@inheritdoc}
*/
public function onBootstrap(EventInterface $event)
{
$app = $event->getApplication();
$moduleRouteListener = new ModuleRouteListener();
$eventManager = $app->getEventManager();
$this->service = $app->getServiceManager();
$moduleRouteListener->attach($eventManager);
$sessionManager = $this->service->get('initSession');
if (!$sessionManager->sessionExists()) {
$sessionManager->start();
Container::setDefaultManager($sessionManager);
}
$eventManager->attach('dispatch', [$this, 'setTitleAndTranslation']);
$eventManager->attach('dispatch.error', [$this, 'onError'], 2);
}
/**
* @param ServerRequestInterface $request
* @param ResponseInterface $response
* @param callable|null $next
* @return ResponseInterface
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
{
$this->sessionManager->start();
Container::setDefaultManager($this->sessionManager);
$container = new Container('initialized');
if (isset($container->init)) {
return $next($request, $response);
}
$this->sessionManager->regenerateId(true);
$container->init = true;
if ($next) {
return $next($request, $response);
}
return $response;
}
/**
* Registers services on the given app.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param Application $app
*/
public function register(Application $app)
{
$app['zend.session.handler._factory'] = $app->protect(function ($type, $options) use($app) {
switch ($type) {
case 'SilexCMF\\ZendSession\\SaveHandler\\Db':
return new Db($app[$options['connection']], new DbOptions());
case 'Zend\\Session\\SaveHandler\\MongoDB':
return new MongoDB($app['mongo'], new MongoDBOptions($options));
}
return null;
});
$app['zend.session.manager'] = $app->share(function () use($app) {
$options = isset($app['zend.session.options']) ? $app['zend.session.options'] : [];
$config = null;
if (isset($options['config'])) {
$config = new SessionConfig();
$config->setOptions($options['config']);
}
$storage = null;
if (isset($options['storage'])) {
$storage = Factory::factory($options['storage']['type'], isset($options['storage']['options']) ? $options['storage']['options'] : []);
}
$handler = null;
if (isset($options['handler'])) {
$handler = $app['zend.session.handler._factory']($options['handler']['type'], isset($options['handler']['options']) ? $options['handler']['options'] : []);
}
$manager = new SessionManager($config, $storage, $handler);
if (isset($options['validators'])) {
/* @var $request \Symfony\Component\HttpFoundation\Request */
$request = $app['request_stack']->getCurrentRequest();
foreach ($options['validators'] as $validator) {
switch ($validator) {
case 'Zend\\Session\\Validator\\HttpUserAgent':
$validator = new $validator($request->server->get('HTTP_USER_AGENT'));
break;
case 'Zend\\Session\\Validator\\RemoteAddr':
$validator = new $validator($request->server->get('REMOTE_ADDR'));
break;
default:
$validator = new $validator();
}
$manager->getValidatorChain()->attach('session.validate', array($validator, 'isValid'));
}
}
Container::setDefaultManager($manager);
return $manager;
});
}
public function onBootstrap(\Zend\EventManager\EventInterface $e)
{
$sm = $e->getApplication()->getServiceManager();
$config = $sm->get('session_config');
$storage = null;
if ($sm->has('session_storage', false)) {
$storage = $sm->get('session_storage');
}
$saveHandler = null;
if ($sm->has('session_save_handler', false)) {
$saveHandler = $sm->get('session_save_handler');
}
$sessionManager = new SessionManager($config, $storage, $saveHandler);
Container::setDefaultManager($sessionManager);
//$sessionManager->start();
}
/**
* Metodo para validar acceso al portal
* @return \Zend\View\Model\ViewModel
*/
public function ingresoAction()
{
if ($this->getRequest()->isPost()) {
$auth = new AuthenticationService();
$validate = $this->getRequest()->getPost();
$authAdapter = new AuthAdapter($this->adapter(), 'usuario', 'usuario_correo', 'usuario_password');
$authAdapter->setIdentity($validate['correo']);
$authAdapter->setCredential(md5($validate['password']));
$resultado = $auth->authenticate($authAdapter);
switch ($resultado->getCode()) {
case Result::FAILURE_IDENTITY_NOT_FOUND:
$this->message = "Usuario y/o contraseña incorrectos";
$this->flashMessenger()->addMessage($this->message);
return $this->redirect()->toUrl($this->getRequest()->getBaseUrl() . '/login');
case Result::FAILURE_CREDENTIAL_INVALID:
$this->message = "Usuario y/o contraseña incorrectos";
$this->flashMessenger()->addMessage($this->message);
return $this->redirect()->toUrl($this->getRequest()->getBaseUrl() . '/login');
case Result::SUCCESS:
$this->flashMessenger()->clearMessages();
$store = $auth->getStorage();
$store->write($authAdapter->getResultRowObject(null, 'usuario_password'));
$sessionConfig = new StandardConfig();
$sessionConfig->setRememberMeSeconds(20)->setCookieLifetime(30)->setCookieSecure(true)->setGcMaxlifetime(60)->setGcDivisor(60);
$sesionMa = new SessionManager($sessionConfig);
$sesionMa->rememberMe(30);
$container = new Container('cbol');
$container->setExpirationSeconds(1800);
$sesionMa->start();
$container->idSession = $auth->getIdentity()->perfil_id;
$permisos = $this->getPermisos($auth->getIdentity()->usuario_id);
$container->permisosUser = $permisos;
$indexProfile = \Login\IndexAllProfile::listIndexAllProfiles($auth->getIdentity()->perfil_id);
if ($indexProfile == 'vias') {
$container->reportesVias = $this->getReportesViales();
}
if ($indexProfile == 'admin') {
$container->sugerencias = $this->getSugerenciasAction();
}
$container->setDefaultManager($sesionMa);
return $this->redirect()->toUrl($this->getRequest()->getBaseUrl() . "/{$indexProfile}");
default:
echo 'Mensaje por defecto';
break;
}
}
}
