protected function setValidator()
{
$filesystem = new FileLoader(new Filesystem(), CONFIG_DIR . DIRECTORY_SEPARATOR . 'langs');
$translator = new Translator($filesystem, Main::$app->web->get('locale', false) ?: 'en');
$this->validator = new ValidatorFactory($translator);
$verifier = new DatabasePresenceVerifier($this->capsule->getDatabaseManager());
$this->validator->setPresenceVerifier($verifier);
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->mergeConfigFrom(__DIR__ . '/../config/captcha.php', 'mews.captcha');
/**
* @param $app
* @return Captcha
*/
$this->app->bind('captcha', function ($app) {
return new Captcha($app['Illuminate\\Filesystem\\Filesystem'], $app['Illuminate\\Config\\Repository'], $app['Intervention\\Image\\ImageManager'], $app['Illuminate\\Session\\Store'], $app['Illuminate\\Hashing\\BcryptHasher'], $app['Illuminate\\Support\\Str']);
});
/**
* @param Captcha $captcha
* @param $config
* @return \Intervention\Image\ImageManager
*/
$this->app['router']->get('captcha/{config?}', 'Chekun\\Captcha\\CaptchaController@draw');
$this->app['validator'] = $this->app->share(function ($app) {
$validator = new Factory($app['translator']);
$validator->setPresenceVerifier($this->app['validation.presence']);
$validator->resolver(function ($translator, $data, $rules, $messages) {
return new CaptchaValidator($translator, $data, $rules, $messages);
});
return $validator;
});
}
public function register(Application $app)
{
$core = $app;
$app['illuminate'] = new Container();
$app['illuminate']['config'] = array('cache.driver' => 'memcached', 'cache.memcached' => array(array('host' => 'localhost', 'port' => '11211')));
$app['illuminate']->bindShared('validator', function ($app) use($core) {
$validator = new Factory($core['translator'], $app);
// The validation presence verifier is responsible for determining the existence
// of values in a given data collection, typically a relational database or
// other persistent data stores. And it is used to check for uniqueness.
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
return $validator;
});
$app['illuminate']->bindShared('cache', function ($app) {
return new CacheManager($app);
});
$app['illuminate']->bindShared('cache.store', function ($app) {
return $app['cache']->driver();
});
$app['illuminate']->bindShared('memcached.connector', function () {
return new MemcachedConnector();
});
}
/**
* @return void
*/
protected function registerValidationFactory()
{
$this->app->singleton('validator', function ($app) {
$validator = new Factory($app['translator'], $app);
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
return $validator;
});
}
/**
* Register the validation factory.
*
* @return void
*/
protected function registerValidationFactory()
{
$validator = new Factory($this->container['translator'], $this->container);
// The validation presence verifier is responsible for determining the existence
// of values in a given data collection, typically a relational database or
// other persistent data stores. And it is used to check for uniqueness.
if (isset($this->container['validation.presence'])) {
$validator->setPresenceVerifier($this->container['validation.presence']);
}
return $validator;
}
/**
* Register any validation services.
*
* @param \Pimple\Container $container
*/
public function register(Container $container)
{
$this->registerPresenceVerifier($container);
$container['validator'] = function () use($container) {
$validator = new Factory($container['translator']);
if (isset($container['validation.presence'])) {
$validator->setPresenceVerifier($container['validation.presence']);
}
return $validator;
};
}
/**
* Create a new Validator factory instance.
*
* @param \Illuminate\Database\Capsule\Manager $db
* @return \Illuminate\Validation\Factory
*/
public function __construct($db)
{
if (!$this->factory) {
/**
* illuminate/translation (Translator) package need for correct work of Validator
*/
$translator = new Translator('en');
$this->factory = new Factory($translator);
/**
* To set database presence verifier we need database connection instance,
* which is implements ConnectionResolverInterface. For this purpose
* Illuminate\Database\Capsule\Manager class, which we get from $db arg,
* have getDatabaseManager() function.
* With defined DatabasePresenceVerifier we can use rules such as:
* unique:table,column,except,idColumn
* exists:table,column
*/
$dbManager = $db->getDatabaseManager();
$this->factory->setPresenceVerifier(new DatabasePresenceVerifier($dbManager));
}
return $this->factory;
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->registerPresenceVerifier();
$this->app['validator'] = $this->app->share(function ($app) {
$validator = new Factory($app['translator'], $app);
// The validation presence verifier is responsible for determining the existence
// of values in a given data collection, typically a relational database or
// other persistent data stores. And it is used to check for uniqueness.
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
return $validator;
});
}
public function testMakeMethodCreatesValidValidator()
{
$translator = m::mock('Symfony\\Component\\Translation\\TranslatorInterface');
$factory = new Factory($translator);
$validator = $factory->make(array('foo' => 'bar'), array('baz' => 'boom'));
$this->assertEquals($translator, $validator->getTranslator());
$this->assertEquals(array('foo' => 'bar'), $validator->getData());
$this->assertEquals(array('baz' => array('boom')), $validator->getRules());
$presence = m::mock('Illuminate\\Validation\\PresenceVerifierInterface');
$factory->extend('foo', function () {
});
$factory->setPresenceVerifier($presence);
$validator = $factory->make(array(), array());
$this->assertEquals(array('foo' => function () {
}), $validator->getExtensions());
$this->assertEquals($presence, $validator->getPresenceVerifier());
}
public function register()
{
$this->app->singleton('validation.presence', function ($app) {
return new DatabasePresenceVerifier($app['db']);
});
$this->app->singleton('validator', function ($app) {
$validator = new Factory($app['translator'], $app);
$validator->resolver(function ($translator, $data, $rules, $messages, $customAttributes) {
return new \App\Http\Services\Validator($translator, $data, $rules, $messages, $customAttributes);
});
// The validation presence verifier is responsible for determining the existence
// of values in a given data collection, typically a relational database or
// other persistent data stores. And it is used to check for uniqueness.
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
return $validator;
});
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->registerPresenceVerifier();
$this->app->singleton('validator', function ($app) {
$validator = new Factory($app['translator'], $app);
// The validation presence verifier is responsible for determining the existence
// of values in a given data collection, typically a relational database or
// other persistent data stores. And it is used to check for uniqueness.
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
// Add validation extensions
$extensions = config('esensi/core::validation.extensions', []);
foreach ($extensions as $extension => $class) {
$validator->extend($extension, $class . '@validate' . ucfirst(studly_case($extension)));
$validator->replacer($extension, $class . '@replace' . ucfirst(studly_case($extension)));
}
return $validator;
});
}
public function testBoot()
{
$translator = Mockery::mock('Symfony\\Component\\Translation\\TranslatorInterface');
$translator->shouldReceive('get');
$presence = Mockery::mock('Illuminate\\Validation\\PresenceVerifierInterface');
$factory = new Factory($translator);
$factory->setPresenceVerifier($presence);
$container = Mockery::mock('Illuminate\\Container\\Container');
$container->shouldReceive('bind');
$container->shouldReceive('offsetGet')->with('translator')->andReturn($translator);
$container->shouldReceive('offsetGet')->with('validator')->andReturn($factory);
$sp = Mockery::mock('Cviebrock\\ImageValidator\\ImageValidatorServiceProvider[package]', array($container));
$sp->shouldReceive('package');
$sp->boot();
$validator = $factory->make(array(), array());
foreach ($validator->getExtensions() as $rule => $class_and_method) {
$this->assertTrue(in_array($rule, $sp->getRules()));
$this->assertEquals('Cviebrock\\ImageValidator\\ImageValidator@' . 'validate' . studly_case($rule), $class_and_method);
list($class, $method) = Str::parseCallback($class_and_method, null);
$this->assertTrue(method_exists($class, $method));
}
}
/**
* Configures Ardent to be used outside of Laravel - correctly setting Eloquent and Validation modules.
* @todo Should allow for additional language files. Would probably receive a Translator instance as an optional argument, or a list of translation files.
*
* @param array $connection Connection info used by {@link \Illuminate\Database\Capsule\Manager::addConnection}.
* Should contain driver, host, port, database, username, password, charset and collation.
*/
public static function configureAsExternal(array $connection)
{
$db = new DatabaseCapsule();
$db->addConnection($connection);
$db->setEventDispatcher(new Dispatcher(new Container()));
//TODO: configure a cache manager (as an option)
// Make this Capsule instance available globally via static methods
$db->setAsGlobal();
$db->bootEloquent();
$translator = new Translator('en');
$translator->addLoader('file_loader', new PhpFileLoader());
$translator->addResource('file_loader', dirname(__FILE__) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'lang' . DIRECTORY_SEPARATOR . 'en' . DIRECTORY_SEPARATOR . 'validation.php', 'en');
self::$externalValidator = true;
self::$validationFactory = new ValidationFactory($translator);
self::$validationFactory->setPresenceVerifier(new DatabasePresenceVerifier($db->getDatabaseManager()));
}
$validator = $validation->make($data, $rules);
if ($validator->fails()) {
$errors = $validator->errors();
}
return $app->render('form.php', ['posted' => true, 'errors' => $errors, 'email' => $_POST['email']]);
});
// For a thorough example, we establish a database connection
// to drive the database presence verifier used by the validator.
// If you do not need to validate against values in the database,
// the database presence verifier and related code can be removed.
$app->get('/database', function () use($app) {
return $app->render('form.php', ['posted' => false, 'errors' => null, 'email' => '']);
});
$app->post('/database', function () use($app) {
$capsule = new Capsule();
$capsule->addConnection(['driver' => 'mysql', 'host' => 'localhost', 'database' => 'illuminate_non_laravel', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '']);
$loader = new FileLoader(new Filesystem(), 'lang');
$translator = new Translator($loader, 'en');
$presence = new DatabasePresenceVerifier($capsule->getDatabaseManager());
$validation = new Factory($translator, new Container());
$validation->setPresenceVerifier($presence);
$data = ['email' => $_POST['email']];
$rules = ['email' => 'required|email|unique:users'];
$errors = null;
$validator = $validation->make($data, $rules);
if ($validator->fails()) {
$errors = $validator->errors();
}
return $app->render('form.php', ['posted' => true, 'errors' => $errors, 'email' => $_POST['email']]);
});
$app->run();
/**
* Create an instance of the Illuminate validation driver.
*
* @return \Deefour\Aide\Validation\AbstractValidator
*/
protected function createIlluminateDriver()
{
$factory = new IlluminateFactory($this->app['translator'], $this->app);
$factory->setPresenceVerifier($this->app['validation.presence']);
return new IlluminateValidator($factory);
}
$options = ['debug' => true, 'cache' => __DIR__ . '/../cache/views/compiled'];
$twig = new \Twig_Environment($app->get('twig.loader'), $options);
// register Twig Extensions
$twig->addExtension(new \Twig_Extension_Debug());
// register Twig globals
$twig->addGlobal('app', $app);
return $twig;
});
/*
Registering Eloquent DB Manager
*/
use Illuminate\Database\Capsule\Manager as Capsule;
$capsule = new Capsule();
$capsule->addConnection(require __DIR__ . '/config/database.php');
$app->bind('capsule', $capsule);
$capsule->setAsGlobal();
$capsule->bootEloquent();
/*
Registering Validator
*/
use Illuminate\Container\Container;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Translation\FileLoader;
use Illuminate\Translation\Translator;
use Illuminate\Validation\Factory;
use Illuminate\Validation\DatabasePresenceVerifier;
$loader = new FileLoader(new Filesystem(), __DIR__ . '/lang');
$translator = new Translator($loader, 'en');
$validation = new Factory($translator, new Container());
$validation->setPresenceVerifier(new DatabasePresenceVerifier(app('capsule')->getDatabaseManager()));
$app->bind('validation', $validation);
/**
* Set the Presence Verifier implementation.
*
* @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
* @return void
*/
public function setPresenceVerifier(PresenceVerifierInterface $presenceVerifier)
{
$this->factory->setPresenceVerifier($presenceVerifier);
}
/**
* Set the database instance used by the presence verifier.
*
* @param \Illuminate\Database\ConnectionResolverInterface $db
* @return void
*/
public function setConnection(ConnectionResolverInterface $db)
{
$this->factory->setPresenceVerifier(new DatabasePresenceVerifier($db));
}
/**
* Set the Presence Verifier implementation.
*
* @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
* @return void
* @static
*/
public static function setPresenceVerifier($presenceVerifier)
{
\Illuminate\Validation\Factory::setPresenceVerifier($presenceVerifier);
}
/**
* Register the database presence verifier.
*
* @param \Illuminate\Database\ConnectionResolverInterface $db
* @return void
*/
public function setPresenceVerifier(ConnectionResolverInterface $db)
{
$presence = new DatabasePresenceVerifier($db);
$this->validator->setPresenceVerifier($presence);
}
