Passwords are always fickle, especially when working with hashed passwords.

I am hashing my password using the following in my Users model:

    public function setPasswordAttribute($password)
    {
        $this->attributes['password'] = Hash::make($password);
    }

When I validate using the following ruleset:

    protected $fillable = [
        'email',
        'password'
    ];

    protected $rules = [
        'creating' => [
            'email' => 'required|email|unique:users,email',
            'password' => 'required|confirmed'
        ]
    ];

I always get passwords don't match. I assume this is because of two things:

1. The password_confirmation field is not saved in the model.
2. The password is already hashed before the validation begins.

Soooo, the big question is: how do you recommend dealing with password validation? :) Thanks!

i got this error when submit form

exception 'ErrorException' with message 'Missing argument 1 for Illuminate\Http\RedirectResponse::withErrors(), called in /Applications/MAMP/htdocs/admin/app/controllers/UsersController.php on line 50 and defined' in /Applications/MAMP/htdocs/admin/vendor/laravel/framework/src/Illuminate/Http/RedirectResponse.php:118 

my controller

public function store()
    {

        $user = new User;
        $user->username = Input::get('username');
        $user->password = Input::get('password');
        $user->email = Input::get('email');


        if ( ! $user->save())
        {
            // The user did not save due to validation errors.
            return Redirect::route('user.users.create')
            ->withErrors($e)
            ->withInput();
        }

        // Post was saved successfully.
        return Redirect::route('user.users.show', $user->id);

    }

Model

<?php

use Toddish\Verify\Models\User as VerifyUser;
use Laracasts\Presenter\PresentableTrait;
use Watson\Validating\ValidatingTrait;

class User extends VerifyUser
{
    protected $table = 'users'; 

    use ValidatingTrait;

    protected $rules = [
        'username'  => 'required|unique:users',
        'email'     => 'required|unique:users',
        'password'  => 'required'
    ];

    protected $validationMessages = [
        'username.unique' => "Username Already Exist"
    ];

    use PresentableTrait;

    protected $presenter = 'UserPresenter';


}

Right now we have a simple implementation of validating events which will get you by if you need it. However, I'd like to better match up with the naming convention of events in Laravel itself. @dalabarge goes into detail in this comment.

This is something I'd like for when we hit version 1.

Hi,

Love trait, thank! But purging is bit of an issue.

Can someone please help. Seems like the trait doesn't purge _confirmation attributes from the model before saving to the persistence layer.

Any help would be appreciated.

Thanks!

I wanna in my model like this

public $validationAttributeNames = [
        'starts_on' => 'Starts On Date',
        'ends_on' => 'Ends On Date',
    ];

Hi this is not working when i used inside my module

i used this for my modules https://github.com/pingpong-labs/modules

this is error message when i try

try
{
$item->saveOrFail();
}
catch (Watson\Validating\ValidationException $e)
{
$errors = $e->getErrors();
return Redirect::back()
->withErrors($errors)
->withInput();
}

Modules\Master\Models\Item model could not be persisted as it failed validation

it's working fine when i used

if ( ! $item->save())
{
return \Redirect::back()
->withErrors($item->getErrors())
->withInput();
} 

but error message and input not show up in my form

Hello,

I'm using standalone Eloquent with Validation trait with following class

use Watson\Validating\ValidatingTrait;

class User extends Illuminate\Database\Eloquent\Model {

    use ValidatingTrait;

    protected $table = "users";
    public $timestamps = false;
    protected $rules = [
        'name'   => 'required',
        'phone'    => 'required',
        'email' => 'required',
        'zone' => 'required'
    ];
    protected $validationMessages = [
        'name.required' => 'Please enter your name'
    ];
    protected $fillable = ['name','zone','email','phone'];

When I do

$user = new User(["attr"=>1,......]); $user->isValid();

I get subject error. I'm not that familiar with eloquent but not sure what it means. Do I need to formulate my own Validate::make()?

laravel/framework (5.1.x-dev ac2d4d4) Breaks Watson\Validating\ValidatingTrait :

Declaration of Watson\Validating\ValidatingTrait::saveOrFail() should be compatible with Illuminate\Database\Eloquent\Model::saveOrFail(array $options = Array)

The documentation provides an example:

$mergedRules = $post->mergeRulesets('saving', 'creating');

How would that be implemented with the following line (but using the merged rulesets instead of the 'my_custom_rules' ruleset)?

$post->isValid('my_custom_rules', false);

I have a situation where i need to have the validation performed on the saving event. I expected that this would happen if I only applied one set of rules and no rulesets in my model like this

protected $rules = [
    'name'             => 'required|min:3',
        ...
];

Unfortunately this doesn't work as i expected it to but instead uses the ValidatingObserver::creating() and ValidatingObserver::updating() instead. I debugged the code and found the issue in ValidatingObserver::saving():

if ( ! $model->getRuleset('creating') && ! $model->getRuleset('updating'))
{
    return $this->performValidation($model, 'saving');
}

The issue is that ValidatingTrait::getRuleset() will merge the saving rules by default. In other words $model->getRuleset('creating') will never become false if any rule gets defined on the model.

On an interesting sidenote in the interface the method is defined like this ValidatingInterface::getRuleset($ruleset, $mergeWithSaving = false). I am not sure if this is the only issue with this, but i would really appreciate to get back the possibility to validate on saving. =)

Hi

Love your work. Not sure if I have stumbled onto something, but for me this approach works ...

$post->isValid(); // true

... and this approach does not

if ( ! $post->save()) ...

I tested this out using the 'alpha' rule and when I entered numbers, $post->isValid() - or my equivalent thereof - returned FALSE (which is good) but $post->save() actually saved the invalid model and returned TRUE.

Hope this is a valid issue.

Hey, after digging a while on a weird issue, here what I get :

Model rule:

'name' => [
                'bail',
                'required',
                'string',
                'max:255',
                (new Rules\Unique('folders', 'name'))
                    ->ignore($this->id)
                    ->where('parent_id', $this->parent_id)
                    ->whereNull($this->getQualifiedDiscardedAtColumn())
                    ->whereNull($this->getQualifiedDeletedAtColumn())
                ,
            ],

 DB::transaction(static function() {
            $x = new Test();
            $x->name = 'test'; # name is not unique, so it will trigger Unicity rule
            $x->saveOrFail(); # fails correctly
        });

The issue is that in the following method

    /**
     * Throw a validation exception.
     *
     * @throws \Watson\Validating\ValidationException
     */
    public function throwValidationException()
    {
        $validator = $this->makeValidator($this->getRules());

        throw new ValidationException($validator, $this);
    }

The validator is not "triggered" with a ->fail(), so message bag is empty right now. Then, my transaction rollback and the unique rule does not fails anymore, so the validator has no messages :/

Won't it be better to do something like this :

    public function throwValidationException()
    {
        $validator = $this->makeValidator($this->getRules());

        throw new ValidationException(tap($validator)->fails(), $this);
    }

in order to populate the validator with errors before anything else in the app happens ?

Hello, me again here!

Below follows the performValidation() function from ValidatingTrait.

    /**
     * Validate the model against it's rules, returning whether
     * or not it passes and setting the error messages on the
     * model if required.
     *
     * @param  array $rules
     * @return bool
     * @throws \Watson\Validating\ValidationException
     */
    protected function performValidation($rules = [])
    {
        $validation = $this->makeValidator($rules);
        $result = $validation->passes();
        $this->setErrors($validation->messages());
        return $result;
    }

I'm just wondering if we can improve this function to validate against related models in addition to the base model. Do you think this can be a good idea?

My use case is just because i want to simplify some of my controllers. Today, they are handling validation from my services this way:

$profile = ProfileService::update($profile, $request->all());

// handle validation for all models
if ($profile->isInvalid() || $profile->address->isInvalid()) {
    return redirect()
        ->back()
        ->withInput()
        ->withErrors(array_merge_recursive(
            $profile->getErrors()->toArray(), 
            $profile->address->getErrors()->toArray()
        ));
}

As you see, my ProfileService::update() function save profile's data into both base and related model. Both models are using this trait. I wanna keep it simple and remove that mess after redirect().

Something like:

$profile = ProfileService::update($profile, $request->all());

// handle validation for all models at once
if ($profile->isInvalid()) {
    $profile->throwValidationException();
}

Issue #177 The attributesToArray method already returns attributes that are mutated and converts Carbon dates to strings. Plus, it adds appended accessors and applies type casting.

I've just noticed that saveOrReturn() raises an exception if $throwValidationExceptions is set true. The documentation suggests that the whole purpose of this function is to avoid throwing an exception, even if the afore-mentioned variable is set. Also I extracted this comment from the code:

/** saveOrReturn()
 * Perform a one-off save that will return a boolean on
 * validation error instead of raising an exception.
 */

It would be nice if I could do the following with my models that use the ValidatingTrait:

function store(Request $request)
{
    return Post::createOrFail($request->all());
}

function update(Request $request, Post $post)
{
    return $post->updateOrFail($request->all());
}

Which would then be equivalent to:

function store(Request $request)
{
    $post = new Post($request->all());

    $post->saveOrFail()

    return $post;
}

function update(Request $request, Post $post)
{
    $post->fill($request->all())->saveOrFail();

    return $post;
}

And just to be complete, this:

$post = Post::newOrFail($request->all());

would be equivalent to:

$post = new Post($request->all());

$post->isValidOrFail();