Form Request in Laravel

### Why use `php artisan make:request`?

1. **Organizes validation logic**: It moves the validation rules and authorization logic out of your controllers into a separate class, keeping your controllers clean and making your code easier to maintain.
2. **Reusability**: You can reuse the request validation logic in different parts of your application.
3. **Authorization**: Along with validation, you can handle request authorization within the form request.

### How to use it?

Run this command in your terminal:

php artisan make:request CustomRequest

– This will create a new form request class in the `app/Http/Requests/` directory (e.g., `app/Http/Requests/CustomRequest.php`).

### Structure of the generated request class

When the request class is generated, it will contain two primary methods:

1. **`authorize` method**:
– This method is used to determine if the user is authorized to make the request. You can return `true` to allow the request or implement logic to restrict access.

public function authorize()
   {
       return true;  // You can replace this with actual authorization logic
   }

2. **`rules` method**:
– This method is where you define your validation rules for the incoming request. You can specify various rules like required, email, max length, etc.

public function rules()
   {
       return [
           'title' => 'required|string|max:255',
           'email' => 'required|email',
           'age' => 'nullable|integer|min:18'
       ];
   }

### Usage in a Controller

Once you have the form request class, you can use it in your controller method by type-hinting the class in the method signature. Laravel will automatically validate the request data using the rules defined in the form request.

use AppHttpRequestsCustomRequest;

public function store(CustomRequest $request)
{
    // The request data is already validated
    $validatedData = $request->validated();
    
    // Perform actions with the validated data
}

This ensures that the incoming request data meets your validation rules before reaching the controller logic.

### Why this happens:
The error suggests that the `$provider` (which is responsible for retrieving users for authentication) is being passed as `null`. This typically happens when there is an issue with the configuration of your authentication guards or providers.

### Possible causes and solutions:

#### 1. **Misconfigured Auth Configuration (config/auth.php)**

The most likely cause is an issue in your `config/auth.php` file. Laravel's authentication system relies on guards and providers being properly configured.

– **Guard**: Defines how users are authenticated (e.g., session, token).
– **Provider**: Defines how users are retrieved from your data source (e.g., Eloquent model, database).

Check your `config/auth.php` file to ensure it's correctly set up.

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',  // Make sure this matches a valid provider
    ],
    'api' => [
        'driver' => 'token',
        'provider' => 'users',
        'hash' => false,
    ],
],

'providers' => [
    'users' => [
        'driver' => 'eloquent',  // This can be 'database' or 'eloquent'
        'model' => AppModelsUser::class, // Ensure this model exists
    ],
],

– **Ensure the provider is not `null`**. In this example, `'users'` must map to a valid provider in the `providers` array.
– Check that the model (e.g., `AppModelsUser`) exists and is correctly referenced.

#### 2. **Missing or Incorrect User Model**

If you are using the `eloquent` provider, ensure that the `User` model exists at the path specified in the configuration file. Laravel usually creates this model by default at `AppModelsUser`.

If it's missing or incorrectly referenced, you'll need to either:
– Create the `User` model manually or
– Correct the path in `config/auth.php`.

'model' => AppModelsUser::class,  // Ensure this is correct

If your `User` model is in a different namespace, update the reference to point to the correct location.

#### 3. **Clear Configuration Cache**

Sometimes, changes to configuration files (like `config/auth.php`) aren't immediately applied because Laravel caches the configuration. To clear the cache, run:

php artisan config:clear

This will ensure your updated configuration is applied.

#### 4. **Check for Custom Providers**

If you have a custom provider defined in your `config/auth.php`, ensure it's properly implemented and registered. For example:

'providers' => [
    'users' => [
        'driver' => 'custom_provider',  // Custom provider name
        'model' => AppModelsUser::class, 
    ],
],

If you're using a custom provider, it must implement the `IlluminateContractsAuthUserProvider` contract.

#### 5. **Check the Session Configuration**

If the issue is related to the session guard, ensure your session configuration is correct. Check `config/session.php` and ensure that the session driver is properly set up. For local development, `file` is often a good default:

'driver' => env('SESSION_DRIVER', 'file'),

Make sure the session driver is correctly configured in your `.env` file:

SESSION_DRIVER=file

#### Summary of Steps:
1. Check and correct your `config/auth.php` file (guards and providers).
2. Ensure your `User` model exists and is properly referenced.
3. Run `php artisan config:clear` to clear configuration cache.
4. If using a custom provider, ensure it implements the correct contract.
5. Ensure the session driver is correctly set.

By following these steps, you should be able to resolve the error and ensure the proper construction of the `SessionGuard`.

### Steps to Fix the Error with the New `admin` Guard

1. **Check Your `config/auth.php` File**

Ensure that the `admin` guard is properly defined in the `config/auth.php` file. You need to define both the guard and the provider for `admin`.

#### Example `config/auth.php` Configuration for `admin` Guard:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],

    'admin' => [  // New guard for admin
        'driver' => 'session',
        'provider' => 'admins',  // Provider should match the one defined below
    ],
],

'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => AppModelsUser::class,  // Default user model
    ],

    'admins' => [  // New provider for admin guard
        'driver' => 'eloquent',
        'model' => AppModelsAdmin::class,  // Ensure this Admin model exists
    ],
],

– **Guards**: You define a new `admin` guard that uses the `session` driver. The `provider` is set to `admins`.
– **Providers**: You define a new `admins` provider that uses the `eloquent` driver, with the `AppModelsAdmin` model.

2. **Ensure the `Admin` Model Exists**

Make sure that the `Admin` model exists and is located where it's referenced (e.g., `AppModelsAdmin`). If not, create it using:

php artisan make:model Admin

This will create an `Admin.php` model in the `app/Models` directory.

3. **Clear Config Cache**

After updating the configuration, it's important to clear the config cache to ensure Laravel uses the latest changes:

php artisan config:clear

4. **Migration and Database Setup**

Ensure that your `admins` table exists in the database. You may need to create a migration for the `admins` table if it doesn't exist:

php artisan make:migration create_admins_table --create=admins

Define the fields for the `admins` table in the migration file (e.g., `id`, `name`, `email`, `password`, etc.), and run the migration:

php artisan migrate

5. **Logging in with the `admin` Guard**

In your controller or middleware, you can now use the `admin` guard like this:

Auth::guard('admin')->attempt(['email' => $email, 'password' => $password]);

if (Auth::guard('admin')->check()) {
    // The admin is authenticated
}

Make sure you are passing the correct guard in your authentication logic.

—

By configuring the `admin` guard and provider correctly in the `config/auth.php` file, ensuring the `Admin` model exists, and clearing the config cache, you should be able to fix the `SessionGuard` error and get your custom admin guard working properly.

Route::get('/dashboard', function () {
return view('admin.dashboard');
})->name('admin.dashboard');

Route::post('logout', [LoginController::class, 'destroy'])->name('admin.logout');

});
apply login for custom gaurd admin in above code

### Step 1: Create LoginController

If you haven't already, create a controller for handling admin logins. You can name it `AdminLoginController`. You can create this controller using the following command:

php artisan make:controller AdminLoginController

### Step 2: Implement Login Logic

In your `AdminLoginController`, you can implement the login functionality. Here’s an example:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;

class AdminLoginController extends Controller
{
    // Show the admin login form
    public function showLoginForm()
    {
        return view('admin.login'); // create a login view
    }

    // Handle login
    public function login(Request $request)
    {
        // Validate the incoming request
        $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);

        // Attempt to log the admin in
        if (Auth::guard('admin')->attempt($request->only('email', 'password'))) {
            // If successful, redirect to the intended page
            return redirect()->intended(route('admin.dashboard'));
        }

        // If unsuccessful, redirect back with an error message
        return back()->withErrors([
            'email' => 'The provided credentials do not match our records.',
        ]);
    }

    // Handle logout
    public function destroy()
    {
        Auth::guard('admin')->logout();
        return redirect()->route('admin.login'); // Redirect to the login page
    }
}

### Step 3: Define the Routes

Now, you can define the necessary routes for the admin authentication in your `web.php` file:

use AppHttpControllersAdminLoginController;

Route::prefix('admin')->group(function () {
    // Login routes
    Route::get('login', [AdminLoginController::class, 'showLoginForm'])->name('admin.login');
    Route::post('login', [AdminLoginController::class, 'login'])->name('admin.login.submit');

    // Protected routes
    Route::middleware('auth:admin')->group(function () {
        Route::get('/dashboard', function () {
            return view('admin.dashboard');
        })->name('admin.dashboard');

        Route::post('logout', [AdminLoginController::class, 'destroy'])->name('admin.logout');
    });
});

### Step 4: Create the Login View

You need to create a view for the admin login form (`resources/views/admin/login.blade.php`). Here’s a simple example of what that might look like:

<!-- resources/views/admin/login.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>Admin Login</title>
</head>
<body>
    <h1>Admin Login</h1>

    @if ($errors->any())
        <div>
            <strong>{{ $errors->first() }}</strong>
        </div>
    @endif

    <form action="{{ route('admin.login.submit') }}" method="POST">
        @csrf
        <div>
            <label for="email">Email:</label>
            <input type="email" name="email" required>
        </div>

        <div>
            <label for="password">Password:</label>
            <input type="password" name="password" required>
        </div>

        <div>
            <button type="submit">Login</button>
        </div>
    </form>
</body>
</html>

### Summary of Implementation Steps
1. **Create `AdminLoginController`** with methods for showing the login form, handling login, and logging out.
2. **Define Routes** for the login form and authentication, ensuring protected routes are under the `auth:admin` middleware.
3. **Create the Login View** to allow admin users to enter their credentials.

### Final Thoughts

With this setup, when a user navigates to `admin/login`, they will see the login form. Upon submitting the form, their credentials will be validated against the `admin` guard. If the credentials are correct, they will be redirected to the admin dashboard; otherwise, they will see an error message.