Session User ID Retrieval

$loggedUserId = Session::get('loggeduid');

### Explanation:
1. **Storing the Value**:

Session::put('loggeduid', Auth::guard($this->guard)->user()->id);

– `Session::put()` stores a key-value pair in the session. The key is `'loggeduid'`, and the value is the `id` of the currently authenticated user for the specified guard (`$this->guard`).

2. **Retrieving the Value**:

$loggedUserId = Session::get('loggeduid');

– `Session::get('loggeduid')` retrieves the value associated with the key `'loggeduid'` from the session.

### Additional Notes:
– Make sure the session is properly configured in your Laravel application.
– If `'loggeduid'` doesn't exist in the session, `Session::get('loggeduid')` will return `null` by default. You can provide a default value as a second parameter:

$loggedUserId = Session::get('loggeduid', 'default_value');

In this case, if the key doesn't exist, `'default_value'` will be returned.

### Syntax:

$model = ModelName::findOrFail($id);

### Example:

Suppose you have a `User` model, and you want to retrieve a user with a specific ID:

use AppModelsUser;

$user = User::findOrFail($id);

– If a user with the specified `$id` exists, it will be returned.
– If no user is found, a `ModelNotFoundException` will be thrown.

### Handling the Exception:
To gracefully handle the exception, you can use a `try-catch` block:

use AppModelsUser;
use IlluminateDatabaseEloquentModelNotFoundException;

try {
    $user = User::findOrFail($id);
} catch (ModelNotFoundException $e) {
    return response()->json(['error' => 'User not found'], 404);
}

### Differences Between `find` and `findOrFail`:
– `find($id)`: Returns the model instance if found, otherwise returns `null`.
– `findOrFail($id)`: Returns the model instance if found, otherwise throws a `ModelNotFoundException`.

### Best Use Case:
– Use `findOrFail` when the absence of the record is considered an error (e.g., when accessing a detail page of a specific resource).
– Use `find` when the absence of the record is acceptable and can be handled without throwing an exception.

Here’s how you can achieve this:

### Example Query:

use AppModelsUser;

$email = 'example@example.com'; // The email to check
$currentUserId = 1; // The current user's ID to exclude

$count = User::where('email', $email)
             ->where('id', '!=', $currentUserId)
             ->count();

### Explanation:
1. **`where('email', $email)`**:
Filters records where the email matches the given email.

2. **`where('id', '!=', $currentUserId)`**:
Excludes the current user's record by checking that the ID is not equal to the specified user ID.

3. **`count()`**:
Counts the number of records that match the conditions.

### Use Case:
This is useful, for example, when validating that an email is unique except for the current user during an update.

—

### Alternative: Unique Validation in Form Requests
If you're using form requests for validation, Laravel provides a simple way to handle this scenario using the `unique` rule:

'email' => 'required|email|unique:users,email,' . $currentUserId,

– `unique:users,email`: Ensures the email is unique in the `users` table.
– The third parameter (`$currentUserId`) tells Laravel to exclude the current user's ID from the uniqueness check.

This approach is simpler and recommended for use in validation scenarios.

### Example Code:

use AppModelsUser;
use IlluminateHttpRequest;

public function update(Request $request, $id)
{
    // Validate the request data
    $validatedData = $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users,email,' . $id,
    ]);

    // Find the user by ID
    $user = User::findOrFail($id);

    // Update the user's name and email
    $user->update([
        'name' => $validatedData['name'],
        'email' => $validatedData['email'],
    ]);

    return response()->json(['message' => 'User updated successfully!', 'user' => $user]);
}

—

### Explanation:
1. **Validation**:
– `name`: Required, must be a string, and cannot exceed 255 characters.
– `email`: Required, must be a valid email, and must be unique in the `users` table except for the user with the given `$id`.

2. **Find User**:
– `User::findOrFail($id)` ensures the user exists. If not, it throws a `ModelNotFoundException`.

3. **Update User**:
– The `update()` method applies the changes to the `name` and `email` fields.

—

### Alternative: Manual Query with Conditional Update
If you need to perform a manual check before updating:

$email = $request->input('email');
$name = $request->input('name');
$currentUserId = $id;

// Check for duplicate email
$emailExists = User::where('email', $email)
                   ->where('id', '!=', $currentUserId)
                   ->exists();

if ($emailExists) {
    return response()->json(['error' => 'Email is already in use by another user'], 422);
}

// Update the user
$user = User::findOrFail($currentUserId);
$user->update([
    'name' => $name,
    'email' => $email,
]);

return response()->json(['message' => 'User updated successfully!', 'user' => $user]);

—

### When to Use Which Approach:
– **Form Requests**: Use the validation approach for simplicity and better separation of concerns.
– **Custom Logic**: Use the manual check approach if you need additional logic beyond validation (e.g., sending notifications or logging).