Delete session on logout

### Option 1: Using `forget()` in the Logout Method
You can use the `Session::forget()` method to delete a specific session key.

**Example:**

use IlluminateSupportFacadesSession;

public function logout(Request $request)
{
    // Log the user out of the application
    Auth::logout();

    // Clear the specific session key
    Session::forget('is_admin');

    // Invalidate the entire session (optional)
    $request->session()->invalidate();

    // Regenerate the session token (optional for security)
    $request->session()->regenerateToken();

    // Redirect to the login page or home
    return redirect('/login');
}

### Option 2: Clearing All Session Data
If you want to clear all session data on logout, you can use:

public function logout(Request $request)
{
    Auth::logout();

    // Clear all session data
    $request->session()->flush();

    $request->session()->regenerateToken();

    return redirect('/login');
}

### Where to Place the Logout Logic
Ensure that the logout logic is within your authentication controller (like `AuthLoginController` or `AuthController`). If you are using Laravel Breeze, Jetstream, or another package, check the package's logout method and add the session clearing logic there.

### Additional Notes
– If you are using Laravel’s default `Auth::logout()` method, remember that it doesn’t automatically clear session data beyond the authentication session.
– Using `$request->session()->invalidate()` ensures that all session data is cleared and a new session ID is generated, which is useful for preventing session fixation attacks.

This will ensure that `Session::put('is_admin', 1);` is removed when the user logs out, preventing any lingering admin sessions.

### Method 1: Using Blade's `@auth` and `@guest` Directives
If you're using different guards (like `admin`, `coach`, etc.), you can utilize the `Auth::guard()` method within your Blade template.

**Example:**

@if(Auth::guard('your_guard')->check() && Auth::guard('your_guard')->user()->is_admin)
    <p>Welcome, Admin!</p>
@else
    <p>Welcome, User!</p>
@endif

### Method 2: Passing Auth Data to All Views (Using Service Providers)
If you want to make `Auth::guard('your_guard')->user()` available globally in all your Blade templates, you can use a service provider like `AppServiceProvider`.

1. **Open `AppProvidersAppServiceProvider.php`**:

2. **Add the following code in the `boot()` method**:

use IlluminateSupportFacadesAuth;
    use IlluminateSupportFacadesView;

    public function boot()
    {
        // Share the current authenticated user (admin guard) to all views
        View::composer('*', function ($view) {
            $view->with('adminUser', Auth::guard('your_guard')->user());
        });
    }

3. **Now, you can use `$adminUser` in your Blade templates**:

@if($adminUser && $adminUser->is_admin)
        <p>Welcome, Admin!</p>
    @else
        <p>Welcome, User!</p>
    @endif

### Method 3: Using a Blade Helper
You can create a custom Blade directive for checking if a user is an admin.

1. **Create a custom Blade directive in `AppServiceProvider.php`**:

use IlluminateSupportFacadesBlade;
    use IlluminateSupportFacadesAuth;

    public function boot()
    {
        Blade::if('isAdmin', function ($guard = 'your_guard') {
            return Auth::guard($guard)->check() && Auth::guard($guard)->user()->is_admin;
        });
    }

2. **Use the custom directive in your Blade templates**:

@isAdmin('your_guard')
        <p>Welcome, Admin!</p>
    @else
        <p>Welcome, User!</p>
    @endisAdmin

### Method 4: Using a Middleware (if needed)
You can create a middleware to check if a user is an admin and then use it in routes or controllers.

This approach ensures that you’re correctly accessing your custom guard within Blade templates and keeping your Blade views clean and maintainable.

### Method 1: Using Middleware

The most efficient way to handle such logic is by using a custom middleware. This allows you to centralize your access control logic.

#### Step 1: Create a Middleware
Run the following command to create a middleware:

php artisan make:middleware AdminMiddleware

#### Step 2: Define Middleware Logic
Open the newly created middleware file at `app/Http/Middleware/AdminMiddleware.php` and add your logic:

<?php

namespace AppHttpMiddleware;

use Closure;
use IlluminateSupportFacadesAuth;

class AdminMiddleware
{
    public function handle($request, Closure $next, $guard = 'web')
    {
        $user = Auth::guard($guard)->user();

        // Check if user is authenticated and is not an admin
        if ($user && $user->is_admin == 0) {
            // Redirect to the dashboard if not an admin
            return redirect('/dashboard');
        }

        return $next($request);
    }
}

#### Step 3: Register Middleware
Open `app/Http/Kernel.php` and add your new middleware to the `$routeMiddleware` array:

protected $routeMiddleware = [
    // other middlewares
    'admin' => AppHttpMiddlewareAdminMiddleware::class,
];

#### Step 4: Apply Middleware to Routes
Now, you can protect the `/admin/user` route by applying the middleware:

// In routes/web.php
Route::middleware(['auth', 'admin'])->group(function () {
    Route::get('/admin/user', [AdminController::class, 'index']);
});

### Method 2: Using Controller Logic
If you don't want to create a middleware, you can handle the check directly in your controller.

#### Example:

public function index()
{
    $user = Auth::user();

    if ($user->is_admin == 0) {
        return redirect('/dashboard');
    }

    // Continue with the rest of your logic
    return view('admin.user.index');
}

### Method 3: Using Route Closure
If `/admin/user` is just a single route, you can handle it directly in the route definition:

Route::get('/admin/user', function () {
    $user = Auth::user();

    if ($user && $user->is_admin == 0) {
        return redirect('/dashboard');
    }

    return view('admin.user.index');
})->middleware('auth');

### Method 4: Blade Template (Not Recommended)
While it's better to handle redirects in the controller or middleware, you can also check in the Blade template:

@if(Auth::user()->is_admin == 0)
    <script>window.location.href = '/dashboard';</script>
@endif

### Which Method to Choose?
– **Middleware** is recommended for centralized and reusable access control.
– **Controller logic** is suitable if you only need this check in a specific controller.
– **Route closure** is a quick fix for single routes.
– **Blade template** should be avoided for access control as it can be bypassed.

By using middleware or controller-based checks, you ensure a clean and maintainable solution.

use IlluminateSupportFacadesDB;

use IlluminateHttpRequest;

use IlluminateSupportFacadesValidator;

use IlluminateSupportFacadesSession;

use IlluminateSupportFacadesHash;

use Auth;

use Redirect;

use AppModelsUser;

class Users extends Controller

{

public function __construct()

{

if (Auth::guard('users')->user()->is_admin == 0) {

return redirect('/admin');

}

}
get id on null

### Solution 1: Use Middleware Instead of the Constructor
A better approach is to use middleware for this kind of access control. Middleware is specifically designed for handling authentication and authorization checks.

#### Step 1: Create Middleware
First, create a custom middleware if you don't have one already:

php artisan make:middleware CheckAdmin

#### Step 2: Define Middleware Logic
Edit the newly created middleware file located at `app/Http/Middleware/CheckAdmin.php`:

<?php

namespace AppHttpMiddleware;

use Closure;
use IlluminateSupportFacadesAuth;

class CheckAdmin
{
    public function handle($request, Closure $next, $guard = 'users')
    {
        // Check if the authenticated user is not an admin
        if (Auth::guard($guard)->check() && Auth::guard($guard)->user()->is_admin == 0) {
            return redirect('/admin');
        }

        return $next($request);
    }
}

#### Step 3: Register Middleware
Open `app/Http/Kernel.php` and add your middleware to the `$routeMiddleware` array:

protected $routeMiddleware = [
    'check.admin' => AppHttpMiddlewareCheckAdmin::class,
];

#### Step 4: Apply Middleware to Your Controller or Routes
In your controller, apply the middleware:

class Users extends Controller
{
    public function __construct()
    {
        $this->middleware('check.admin');
    }

    public function index()
    {
        // Your controller logic
        return view('users.index');
    }
}

Alternatively, you can apply the middleware directly to your routes in `routes/web.php`:

Route::group(['middleware' => ['auth:users', 'check.admin']], function () {
    Route::get('/admin/user', [Users::class, 'index']);
});

### Solution 2: Check in Each Controller Method (Not Recommended)
If you prefer to keep the logic inside your controller without middleware, you can move the check into each method rather than the constructor:

public function index()
{
    if (Auth::guard('users')->check() && Auth::guard('users')->user()->is_admin == 0) {
        return redirect('/admin');
    }

    // Your controller logic
    return view('users.index');
}

### Explanation
– Using middleware is the preferred solution because it separates authentication logic from your controller and ensures the authentication context is fully loaded before checking.
– The constructor method is not ideal for handling authentication checks because it runs before the middleware stack is applied, which can lead to issues with the authentication context.

By using middleware, you can ensure that only admins can access certain routes, keeping your application secure and your codebase clean.