Added UniqueEloquentTest; Renamed ExistEloquent to ExistsEloquent

Author: korridor

composer.json

@@ -11,7 +11,7 @@
     ],
     "license": "MIT",
     "require": {
-        "php": "7.*",
+        "php": "^7.1|^7.2|^7.3",
         "illuminate/support": "^5.8|^6.0"
     },
     "require-dev": {

phpunit.xml

@@ -11,7 +11,7 @@
          stopOnFailure="false">
     <testsuites>
         <testsuite name="Feature">
-            <directory>tests</directory>
+            <directory>tests/Feature</directory>
         </testsuite>
     </testsuites>
     <filter>

readme.md

@@ -1,16 +1,60 @@
 # Laravel model validation rules
 
+This package is an alternative to the Laravel built-in validation rules `exist` and `unique`.
+This has the following advantages:
+
+ - It uses existing models instead of directly querying the database.
+ - The rule can be easily extended with the Eloquent builder.
+ - Softdeletes are working
+
 ## Installation
 
+You can install the package via composer with following command:
+
 ```bash
 composer require korridor/laravel-model-validation-rules
 ```
 
+### Translation
+
+If you want to customize the translations of the validation errors you can publish the translations 
+of the package to the `resources/lang/vendor/modelValidationRules` folder.
+
 ```bash
 php artisan vendor:publish --provider="Korridor\LaravelModelValidationRules\ModelValidationServiceProvider"
 ```
 
-## Usage
+## Rules
+
+### ExistEloquent
+
+### UniqueEloquent
+
+## Usage examples
+
+**PostStoreRequest**
+
+```php
+public function rules()
+{
+    $postId = $this->post->id;
+    
+    return [
+        'username' => [new UniqueEloquent(User::class, 'username')],
+        'title' => ['string'],
+        'content' => ['string'],
+        'comments.*.id' => [
+            'nullable',
+            new ExistEloquent(Comment::class, null, function (Builder $builder) use ($postId) {
+                return $builder->where('post_id', $postId);
+            }),
+        ],
+        'comments.*.content' => ['string']
+    ];
+}
+```
+
+**PostUpdateRequest**
 
 ```php
 public function rules()
@@ -19,6 +63,7 @@ public function rules()
 
     return [
         'id' => [new ExistEloquent(Post::class)],
+        'username' => [new UniqueEloquent(User::class, 'username')->ignore($postId)],
         'title' => ['string'],
         'content' => ['string'],
         'comments.*.id' => [
@@ -34,6 +79,8 @@ public function rules()
 
 ## Contributing
 
+I am open for suggestions and contributions. Just create an issue or a pull request.
+
 ### Testing
 
 ```bash
@@ -48,6 +95,11 @@ composer fix
 composer lint
 ```
 
+## Credits
+
+The structure of the repository and the TestClass is inspired by the 
+project [laravel-validation-rules](https://github.com/spatie/laravel-validation-rules) by [spatie](https://github.com/spatie).
+
 ## License
 
 The MIT License (MIT). Please see [license file](license.md) for more information.

resources/lang/de/validation.php

@@ -1,5 +1,6 @@
 <?php
 
 return [
-    'exist_model' => 'Die Ressource existiert nicht.'
+    'exists_model' => 'Die Ressource existiert nicht.',
+	'unique_model' => 'Die Ressource existiert bereits.',
 ];

resources/lang/en/validation.php

@@ -1,5 +1,6 @@
 <?php
 
 return [
-    'exist_model' => 'The resource does not exist.'
+    'exists_model' => 'The resource does not exist.',
+	'unique_model' => 'The resource already exists.',
 ];

src/Rules/ExistEloquent.php renamed to src/Rules/ExistsEloquent.php

@@ -3,10 +3,10 @@
 namespace Korridor\LaravelModelValidationRules\Rules;
 
 use Closure;
-use Eloquent;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Contracts\Validation\Rule;
 
-class ExistEloquent implements Rule
+class ExistsEloquent implements Rule
 {
     /**
      * @var string
@@ -44,7 +44,7 @@ public function __construct(string $model, ?string $key = null, ?Closure $builde
     {
         $this->model = $model;
         $this->key = $key;
-        $this->builderClosure = $builderClosure;
+		$this->setBuilderClosure($builderClosure);
     }
 
     /**
@@ -58,10 +58,10 @@ public function passes($attribute, $value): bool
     {
         $this->attribute = $attribute;
         $this->value = $value;
-        /** @var Eloquent $builder */
+        /** @var Model $builder */
         $builder = new $this->model();
         if (null === $this->key) {
-            $builder = $builder->where($builder->getKeyName(), $value);
+            $builder = $builder->where((new $this->model())->getKeyName(), $value);
         } else {
             $builder = $builder->where($this->key, $value);
         }
@@ -80,10 +80,27 @@ public function passes($attribute, $value): bool
      */
     public function message(): string
     {
-		return trans('modelValidationRules::validation.exist_model', [
+		return trans('modelValidationRules::validation.exists_model', [
 			'attribute' => $this->attribute,
 			'model' => class_basename($this->model),
 			'value' => $this->value,
 		]);
     }
+
+	/**
+	 * @param Closure|null $builderClosure
+	 */
+	public function setBuilderClosure(?Closure $builderClosure) {
+		$this->builderClosure = $builderClosure;
+	}
+
+	/**
+	 * @param Closure $builderClosure
+	 * @return $this
+	 */
+	public function query(Closure $builderClosure): ExistsEloquent
+	{
+		$this->setBuilderClosure($builderClosure);
+		return $this;
+	}
 }

src/Rules/UniqueEloquent.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace Korridor\LaravelModelValidationRules\Rules;
+
+use Closure;
+use Illuminate\Contracts\Validation\Rule;
+use Illuminate\Database\Eloquent\Model;
+
+class UniqueEloquent implements Rule {
+
+	/**
+	 * @var string
+	 */
+	private $model;
+
+	/**
+	 * @var string|null
+	 */
+	private $key;
+
+	/**
+	 * @var Closure|null
+	 */
+	private $builderClosure;
+
+	/**
+	 * @var string
+	 */
+	private $attribute;
+
+	/**
+	 * @var mixed
+	 */
+	private $value;
+
+	/**
+	 * @var mixed
+	 */
+	private $ignoreId;
+
+	/**
+	 * @var string
+	 */
+	private $ignoreColumn;
+
+	/**
+	 * UniqueEloquent constructor.
+	 * @param string $model
+	 * @param string|null $key
+	 * @param Closure|null $builderClosure
+	 */
+	public function __construct(string $model, ?string $key = null, ?Closure $builderClosure = null) {
+		$this->model = $model;
+		$this->key = $key;
+		$this->setBuilderClosure($builderClosure);
+	}
+
+	/**
+	 * Determine if the validation rule passes.
+	 *
+	 * @param  string $attribute
+	 * @param  mixed $value
+	 * @return bool
+	 */
+	public function passes($attribute, $value): bool {
+		$this->attribute = $attribute;
+		$this->value = $value;
+		/** @var Model $builder */
+		$builder = new $this->model();
+		$builder = $builder->where($this->key === null ? (new $this->model())->getKeyName() : $this->key, $value);
+		if (null !== $this->builderClosure) {
+			$builderClosure = $this->builderClosure;
+			$builder = $builderClosure($builder);
+		}
+		if($this->ignoreId !== null) {
+			$builder = $builder->whereNot(
+				$this->ignoreColumn === null ? (new $this->model())->getKeyName() : $this->ignoreColumn,
+				$this->ignoreId
+			);
+		}
+
+		return $builder->count() === 0;
+	}
+
+	/**
+	 * Get the validation error message.
+	 *
+	 * @return string|array
+	 */
+	public function message(): string {
+		return trans('modelValidationRules::validation.unique_model', [
+			'attribute' => $this->attribute,
+			'model' => class_basename($this->model),
+			'value' => $this->value,
+		]);
+	}
+
+	/**
+	 * @param Closure|null $builderClosure
+	 */
+	public function setBuilderClosure(?Closure $builderClosure): void {
+		$this->builderClosure = $builderClosure;
+	}
+
+	/**
+	 * @param Closure $builderClosure
+	 * @return $this
+	 */
+	public function query(Closure $builderClosure): UniqueEloquent
+	{
+		$this->setBuilderClosure($builderClosure);
+		return $this;
+	}
+
+	/**
+	 * @param mixed $id
+	 * @param string|null $column
+	 */
+	public function setIgnore($id, ?string $column = null): void
+	{
+		$this->ignoreId = $id;
+		$this->ignoreColumn = $column;
+	}
+
+	/**
+	 * @param $id
+	 * @param string|null $column
+	 * @return UniqueEloquent
+	 */
+	public function ignore($id, ?string $column = null): UniqueEloquent
+	{
+		$this->setIgnore($id, $column);
+
+		return $this;
+	}
+}