<?php
 
namespace illusion;
 
use illusion\Common\Cms\CMS;
use illusion\Common\Plugins\ConnectionPlugin;
use illusion\Common\Plugins\ForwardPlugin;
use Phalcon\DI\FactoryDefault;
use Phalcon\DI;
use Phalcon\Mvc\View;
use Phalcon\Crypt;
use Phalcon\Mvc\Dispatcher;
use Phalcon\Mvc\Url as UrlResolver;
use Pdo;
use Phalcon\Cache\Backend\File;
use Phalcon\Cache\Frontend\Data;
use Phalcon\Db\Adapter\Cacheable\Mysql;
use Phalcon\Db\Adapter\Pdo\Mysql as Connection;
use Phalcon\Mvc\View\Engine\Volt as VoltEngine;
use Phalcon\Mvc\Model\Metadata\Files as MetaDataAdapter;
use Phalcon\Session\Adapter\Files as SessionAdapter;
use Phalcon\Flash\Direct as Flash;
use illusion\Common\Auth\Auth;
use illusion\Common\Models\Info;
use illusion\Common\Models\Languages;
use Phalcon\Flash\Session;
use illusion\Common\Acl\Acl;
use illusion\Mail\Mail;
use Phalcon\Logger;
use Phalcon\Events\Manager;
use Phalcon\Logger\Adapter\File as FileLogger;
use illusion\Common\Utils\Utils;
use Phalcon\Http\Response\Cookies;
use Phalcon\Http\Request;
use Phalcon\Translate\Adapter\Database;
use ReflectionClass;
use ReflectionMethod;
use illusion\Common\Plugins\NotFoundPlugin;
use illusion\Common\Plugins\SecurityPlugin;
 
/**
 * The FactoryDefault Dependency Injector automatically register the right services providing a full stack framework
 */
$di = new FactoryDefault();
 
 
/**
 * Register the global configuration as config
 */
$di->set('config', $config);
 
/**
 * Loading routes from the routes.php file
 */
$di->set('router', function () use ($config) {
    return require APPS_DIR . '/config/routes.php';
});
 
/**
 * The URL component is used to generate all kind of urls in the application
 */
$di->set('url', function () use ($config) {
    $url = new UrlResolver();
    $url->setBaseUri($config->application->publicUrl . $config->application->baseUri);
    return $url;
}, true);
 
/**
 * Setting up the view component
 */
$di->set('view', function () use ($config) {
 
    $view = new View();
 
    $view->registerEngines(['.volt' => function ($view, $di) use ($config) {
        $volt = new VoltEngine($view, $di);
        $volt->setOptions([
            'compiledPath' => CACHE_DIR . '/volt/',
            'compiledSeparator' => '_',
            'compileAlways' => (APPLICATION_ENV == 'dev') ? false : true
        ]);
        return $volt;
    }]);
 
    return $view;
}, true);
 
 
/**
 * Database connection is created based in the parameters defined in the configuration file
 */
$di->set('db', function () use ($config) {
 
    try {
 
        //    $connection = new Mysql([
        //        'host' => $config->database->host,
        //        'username' => $config->database->username,
        //        'password' => $config->database->password,
        //        'dbname' => $config->database->dbname,
        //        'charset' => $config->database->charset,
        //        'options' => [Pdo::ATTR_EMULATE_PREPARES => false]
        //    ]);
 
        $connection = new Connection(
            array(
                "host" => $config->database->host,
                "username" => $config->database->username,
                "password" => $config->database->password,
                "dbname" => $config->database->dbname,
                "charset" => $config->database->charset
            )
        );
        if (debugSQL) {
            $eventsManager = new Manager();
            $logger = new FileLogger(LOGS_DIR . '/debug.log');
            $eventsManager->attach('db', function ($event, $connection) use ($logger) {
                if ($event->getType() == 'beforeQuery') {
                    $logger->log($connection->getSQLStatement(), Logger::INFO);
                }
            });
            $connection->setEventsManager($eventsManager);
        }
 
        //    $frontCache = new Data(['lifetime' => 3600]);
        ////    $frontCache = new Data(['lifetime' => 3600]);
        //    // File backend settings
        //    $connection->setCache(new File($frontCache, ['cacheDir' => CACHE_DIR . '/db/']));
 
        return $connection;
 
    } catch (\PDOException $e) {
        throw new \PDOException("Error: " . $e->getMessage());
    }
 
});
 
if (APPLICATION_ENV == 'pro') {
    $di->set('modelsMetadata', function () use ($config) {
        return new MetaDataAdapter([
            'metaDataDir' => CACHE_DIR . '/metaData/'
        ]);
    });
}
 
/**
 * Start the session the first time some component request the session service
 */
$di->set('session', function () {
    $session = new SessionAdapter();
    $session->start();
    return $session;
});
 
$di->set('cookies', function () {
    $cookies = new Cookies();
    $cookies->useEncryption(false);
    return $cookies;
});
 
/**
 * Crypt service
 */
$di->set('crypt', function () use ($config) {
    $crypt = new Crypt();
    $crypt->setKey($config->application->cryptSalt);
    return $crypt;
});
 
$di->set('dispatcher', function () use ($di) {
 
    $evManager = $di->getShared('eventsManager');
    $evManager->attach('dispatch:beforeDispatch', new SecurityPlugin);
    $evManager->attach('dispatch:beforeException', new NotFoundPlugin);
    $evManager->attach('dispatch:beforeForward', new ForwardPlugin);
 
    $dispatcher = new Dispatcher();
 
    $dispatcher->setEventsManager($evManager);
    return $dispatcher;
}, true
);
 
 
/**
 * Flash service with custom CSS classes
 */
$di->set('flash', function () {
    return new Session([
        'success' => 'alert alert-success alert-dismissable fade in',
        'notice' => 'alert alert-info alert-dismissable fade in',
        'warning' => 'alert alert-warning alert-dismissable fade in',
        'error' => 'alert alert-danger alert-dismissable fade in'
    ]);
});
 
/**
 * Custom authentication component
 */
$di->setShared('auth', function () {
    return new Auth();
});
 
$di->setShared('utils', function () {
    return new Utils();
});
 
$di->setShared('cms', function () {
    return new CMS();
});
 
/**
 * Access Control List
 */
$di->set('acl', function () {
    return new Acl();
});
/**
 * Access Control List
 */
$di->setShared('mobiledetect', function () {
    return new \Mobile_Detect();
});
 
$di->setShared('t', function ($lang = false) use ($config, $di) {
 
    global $lang;
 
    $language = DI::getDefault()->getShared('auth')->getActiveLanguage();
    if (!$language) {
        $request = new Request();
        $lang = $request->getBestLanguage();
        if (!$lang) {
            $lang = 'es';
        }
 
        $language = Languages::findFirstByLang($lang);
        if (!$language) {
            $lang = 'es';
        } else {
            $lang = $language->lang;
        }
    } else {
        $lang = $language->lang;
    }
 
 
    return new Database([
        'db' => $di->getDefault()->getDb(),
        'table' => 'translations',
        'language' => $lang,
    ]);
});
 
$di->set('connectionPlugin', function () {
    return new ConnectionPlugin();
});
 
 
/*
 * Marcando como shared el modulo al cargalo esto deja disponibles las "cosicas"
*/
foreach ($config->modules as $module) {
    $dir = preg_replace("/\/Module.php$/", "", $module['path']);
    // Register Namespace for Shared Module (will not be called by dispatch)
    if (array_key_exists('shared', $module) && $module['shared']) {
        $namespace = preg_replace('/\\\Module$/', "", $module['className']);
        $loader->registerNamespaces(array($namespace => $dir), true);
        // Loading Module class bootloader Reflection Instance
        $reflexion = new ReflectionClass($module['className']);
        $instance = $reflexion->newInstanceWithoutConstructor();
        // Execute every 'register' methods
        foreach ($reflexion->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if (preg_match('/^register/', $method->name)) {
                $instance->{$method->name}($di);
            }
        }
    }
}

<?php
 
namespace illusion\Modules\Users\Controllers;
 
 
use illusion\Common\Utils\Utils;
use illusion\Modules\Users\Forms\ConfirmaccountForm;
use illusion\Modules\Users\Forms\LoginForm;
use illusion\Modules\Users\Forms\ForgotPasswordForm;
use illusion\Modules\Users\Models\PasswordChanges;
use illusion\Modules\Users\Models\Users;
use illusion\Modules\Users\Models\ResetPasswords;
use illusion\Common\Auth\Exception;
use Phalcon\Mvc\View;
use Phalcon\Mvc\Controller;
 
class AuthController extends Controller
{
 
    public function loginAction()
    {
 
        $this->view->setRenderLevel(View::LEVEL_ACTION_VIEW);
        $this->view->setVars(
            array(
                'pageTitle' => $this->t->_('Iniciar sesión'),
                'pageTitleSmall' => ''
            )
        );
 
 
        $form = new LoginForm();
 
        if (!$this->request->isPost()) {
            if ($this->auth->hasRememberMe()) {
                return $this->auth->loginWithRememberMe();
            }
        } else {
 
            if ($form->isValid($this->request->getPost()) == false) {
                foreach ($form->getMessages() as $message) {
                    $this->flash->error($message);
                }
            } else {
 
                try {
                    $this->auth->check(array(
                        'email' => $this->request->getPost('email', 'email'),
                        'password' => $this->request->getPost('password', 'striptags'),
                        'remember' => $this->request->getPost('remember')
                    ));
                    $this->session->remove("lock");
                    $this->session->remove("referer");
                    $url = 'core/index';
 
                    if ($this->session->has('returnTo')) {
                        $returnTo = $this->session->get('returnTo');
                        if (!strpos($returnTo, 'users/login')) {
                            $url = $returnTo;
                        }
                        $this->session->remove('returnTo');
                    }
                    return $this->response->redirect($url);
                } catch (Exception $e) {
                    $this->flash->error($e->getMessage());
                }
            }
        }
 
        $this->view->setVar('loginForm', new LoginForm());
        $this->view->setVar('forgotForm', new ForgotPasswordForm());
    }
 
    public function confirmaccountAction($code)
    {
        $user = Users::findFirstByCode($code);
 
        if (!$user) {
            $this->flash->warning($this->t->_('El enlace ha caducado, puede solicitar una recuperación de contraseña.'));
            return $this->dispatcher->forward(array(
                'module' => 'users',
                'controller' => 'auth',
                'action' => 'login'
            ));
        }
 
        if ($user->used == 'Y') {
            $this->flash->warning($this->t->_('El enlace ya ha sido utilizado, puede solicitar una recuperación de contraseña.'));
            return $this->dispatcher->forward(array(
                'module' => 'users',
                'controller' => 'auth',
                'action' => 'login'
            ));
        }
 
 
        $this->view->setRenderLevel(View::LEVEL_ACTION_VIEW);
        $form = new ConfirmaccountForm($user);
 
//        Utils::po($this->request->getPost());
//        die();
        if ($this->request->isPost()) {
            
            if ($form->isValid($this->request->getPost()) == false) {
                foreach ($form->getMessages() as $message) {
                    $this->flash->error($message);
                }
            } else {
                $user = Users::findFirstByHash($this->request->getPost('hash'));
                if (!$user) {
                    $this->flash->warning($this->t->_('El enlace ha caducado, puede solicitar una recuperación de contraseña.'));
                    return $this->dispatcher->forward(array(
                        'module' => 'users',
                        'controller' => 'auth',
                        'action' => 'login'
                    ));
                }
                $password = $this->request->getPost('passwordNew');
                $passwordProfesto = $this->request->getPost('pin');
 
                $user->password = $this->security->hash($password);
                $user->passwordProfesto = $this->security->hash($passwordProfesto);
 
                $passwordChange = new PasswordChanges();
                $passwordChange->user = $user;
                $passwordChange->ipAddress = $this->request->getClientAddress();
                $passwordChange->userAgent = $this->request->getUserAgent();
                $passwordChange->createdAt = date('Y-m-d H:i:s');
                $user->used = 'Y';
                $user->code = '';
 
                $user->tmpPassword = $password;
                $user->update();
 
                $this->auth->authUserById($user->id);
                $this->flash->success($this->t->_('Contraseña guardada correctamente, bienvenid@ a Profesto.'));
                return $this->response->redirect('/');
            }
        }
        $this->view->form = $form;
        $this->view->code = $code;
    }
 
}

<?php
ini_set("session.cookie_lifetime","14400");
ini_set("session.gc_maxlifetime","14000");
 
use Phalcon\Mvc\Application;
 
error_reporting(E_ALL);
 
 
date_default_timezone_set('Europe/Madrid');
setlocale(LC_ALL, array("es_ES"));
setlocale(LC_MONETARY, 'es_ES');
 
define('debug', true);
define('debugSQL', false);
 
if (!defined('APPLICATION_ENV')) {
    define('APPLICATION_ENV', 'pro');
}
 
if (debug) {
    (new \Phalcon\Debug())->listen();
}
 
//try {
if (!defined('BASE_DIR')) {
    define('BASE_DIR', dirname(__DIR__));
}
 
include BASE_DIR . '/apps/config/constants.php';
 
include BASE_DIR . '/apps/config/c_modules.php';
 
$config = include APPS_DIR . '/config/environment/' . APPLICATION_ENV . '/base-config.php';
$ini_file = APPS_DIR . '/config/environment/' . APPLICATION_ENV . '/base-config.ini';
 
$config2 = new \Phalcon\Config\Adapter\Ini($ini_file);
 
$config->merge($config2);
 
include APPS_DIR . '/config/loader.php';
include APPS_DIR . '/config/services.php';
 
$application = new Application();
$application->setDI($di);
 
require APPS_DIR . '/config/modules.php';
 
echo $application->handle()->getContent();