Unit4 - Subjective Questions

In Laravel, the Illuminate\Http\Request instance provides several methods to retrieve user input.

Retrieving All Input

To retrieve all incoming request input data as an array, you can use the all method. This returns an array containing all input values, regardless of whether they came from the query string or the POST body.

php
request->all();

Retrieving Specific Input

To retrieve a single input value, use the input method. This method accepts the name of the input field as the first argument and an optional default value as the second argument.

php
request->input('name');
request->input('name', 'Sally'); // With default value

Difference:

• all() returns an associative array of all input keys and values.
• input() returns a specific scalar value (string, integer, etc.) or null/default if the key does not exist.

Laravel provides specific methods on the Request instance to check for the presence of input data:

1. has() Method:
   The has method returns true if the value is present on the request. It can check for a single value or an array of values.
   php
   if ($request->has('email')) {
   // ...
   }

2. whenHas() Method:
   This method executes a closure if a value is present.
   php
   input) {
   // ...
   });

3. filled() Method:
   The filled method returns true if a value is present on the request and is not empty.
   php
   if ($request->filled('email')) {
   // ...
   }

4. missing() Method:
   The missing method returns true if the value is not present on the request.
   php
   if ($request->missing('name')) {
   // ...
   }

Concept of Old Input

Laravel allows you to keep input from one request during the next request. This feature is particularly useful for re-populating forms after detecting validation errors. This data is stored in a temporary session (flash data).

Flashing Input

The flash method on the Request instance will flash the current input to the session so that it is available during the user's next request to the application.

php
$request->flash();

You can also flash only specific input using flashOnly or flashExcept:

php
$request->flashOnly(['username', 'email']);
$request->flashExcept('password');

Retrieving Old Input

To retrieve flashed input from the previous request, use the old method on the Request instance.

php
request->old('username');

In Blade templates, the global helper old() is commonly used to repopulate form values:

html
<input type="text" name="username" value="{{ old('username') }}">

In Laravel, uploaded files are handled via the Illuminate\Http\Request instance.

Accessing Uploaded Files

You can access uploaded files using the file method or using dynamic properties. The method returns an instance of Illuminate\Http\UploadedFile, which extends the PHP SplFileInfo class.

php
// Using method
request->file('photo');

// Using dynamic property
request->photo;

Verifying Validity

Before processing a file (e.g., moving or storing it), it is crucial to verify that the file was uploaded successfully without errors. This is done using the isValid method:

php
if ($request->file('photo')->isValid()) {
// The file was uploaded successfully...
}

This checks if there were any upload errors (like exceeding upload_max_filesize in php.ini) during the HTTP transfer.

Laravel's UploadedFile class provides a store method to save an uploaded file to one of the configured filesystems (local, S3, etc.).

The store Method

The store method accepts the path where the file should be stored relative to the filesystem's root configured directory. It generates a unique ID to serve as the filename.

Syntax:
php
request->file('avatar')->store('path/to/directory');

Specifying Disk

You can specify a storage disk (defined in config/filesystems.php) as the second argument:

php
request->file('avatar')->store('avatars', 's3');

Storing with Original Name

If you do not want a randomly generated filename, you can use storeAs:

php
request->file('avatar')->storeAs(
'avatars', $request->user()->id . '_avatar.jpg'
);

The method returns the path to the file relative to the disk's root.

Retrieving Cookies

Cookies in Laravel can be retrieved from the Illuminate\Http\Request instance using the cookie method.

php
request->cookie('name');

Alternatively, you can use the Cookie facade:
php
use Illuminate\Support\Facades\Cookie;
$value = Cookie::get('name');

Security (Encryption)

By default, all cookies created by Laravel are encrypted and signed.

• Encryption: Ensures the contents of the cookie cannot be viewed by the client.
• Signing: Ensures the cookie is not modified by the client.

When a cookie is retrieved, Laravel automatically decrypts it. If the cookie has been tampered with, the value will be invalid and discarded. This relies on the APP_KEY defined in the .env file.

Attaching to Response

In Laravel, cookies are typically attached to the outgoing Illuminate\Http\Response instance using the withCookie method or the cookie helper.

php
return response('Hello World')->cookie(
'name', 'value', $minutes
);

Using Cookie::queue

Often, you might want to set a cookie before the response instance has been created (e.g., inside a controller action or middleware). The Cookie::queue method allows you to queue a cookie to be attached to the response automatically when it is eventually sent by the framework.

php
use Illuminate\Support\Facades\Cookie;

// Queue the cookie for the next response
Cookie::queue('name', 'value', 60);

This places the cookie in a temporary storage, and the AddQueuedCookiesToResponse middleware attaches it to the HTTP response headers.

Mailables

In Laravel, each type of email sent by the application is represented as a "Mailable" class. These classes are stored in the app/Mail directory. They encapsulate the logic for building the email, including the subject, view, and attachments.

Structure of a Mailable Class

A Mailable class typically extends Illuminate\Mail\Mailable and uses the Queueable and SerializesModels traits.

The build Method

All logic for configuring the email is done inside the build method. Within this method, you call various methods like from, subject, view, and attach to configure the email's presentation and delivery.

Example:
php
public function build()
{
return $this->from('example@example.com')
->subject('Order Shipped')
->view('emails.orders.shipped');
}

Data required by the view is usually passed via the class constructor and assigned to public properties, which are automatically available in the view.

To send a message, use the to method on the Mail facade. The to method accepts an email address, a user instance, or a collection of users. Once the recipient is specified, pass an instance of the Mailable class to the send method.

Code Snippet:

php
namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;

class OrderController extends Controller
{
public function store(Request $request)
{
request->order_id);

    // Send the email
    Mail::to(order));
}

}

Laravel Localization

Laravel's localization features allow applications to support multiple languages by retrieving strings in various languages easily. It provides a convenient way to retrieve strings from language files based on the current locale of the application.

Storing Translation Strings

Translations are stored in the lang (or resources/lang) directory. There are two supported methods:

1. Short Keys (PHP files):
   Used for structured data. Files are stored in directories named after the locale (e.g., lang/en/messages.php).
   php
   // lang/en/messages.php
   return [
   'welcome' => 'Welcome to our application',
   ];

2. JSON Strings:
   Used for applications with many translation strings. Files are stored as JSON files in the root of the lang directory (e.g., lang/es.json).

   {
   "I love programming.": "Me encanta programar."
   }

Retrieval

Strings are retrieved using the __ helper function or the @lang Blade directive.

php
echo ('messages.welcome');
echo ('I love programming.');

Laravel allows you to define placeholders in translation strings. These placeholders usually start with a colon :. When retrieving the string, you pass an array of replacements as the second argument to the translation function.

Defining the String (e.g., in lang/en/messages.php):
php
'welcome' => 'Welcome, :name',

Retrieving with Replacement:
To replace :name with a dynamic value:

php
echo __('messages.welcome', ['name' => 'John']);

Output:
Welcome, John

Capitalization:
If the placeholder is capitalized (:Name), the replacement value will be capitalized automatically (e.g., john becomes John). If it is all caps (:NAME), the value becomes all caps.

Laravel Sessions

Since HTTP is stateless, sessions provide a way to store information about the user across multiple requests. Laravel ships with a variety of session backends that are accessed through a unified API.

Available Session Drivers

Configuration is found in config/session.php. Common drivers include:

1. file: Sessions are stored in storage/framework/sessions. This is the default driver.
2. cookie: Sessions are stored securely in encrypted cookies on the user's browser.
3. database: Sessions are stored in a relational database. This requires a table (typically named sessions) to store the session ID and payload.
4. redis / memcached: Sessions are stored in these fast, cache-based stores, ideal for high-performance applications.

There are two primary ways to access session data in Laravel:

1. Using the Request Instance

The Illuminate\Http\Request instance allows access via the session() method.

php
public function show(Request id)
{
request->session()->get('key');

// With a default value if 'key' is missing
request->session()->get('key', 'default');

}

2. Using the Global Session Helper

The global session() helper allows access anywhere in the application (controllers, views, etc.).

• Retrieving: Pass the key name.
  php
  $value = session('key');
  $value = session('key', 'default');

• Storing: Pass an array of key/value pairs.
  php
  session(['key' => 'value']);

To store data in the session, you generally use the session instance retrieved via the request or the helper.

1. The put Method

The put method is used to store a specific key-value pair in the session.

php
// Via Request
$request->session()->put('key', 'value');

// Via Helper
session(['key' => 'value']);

2. The push Method

The push method is used when the session value is an array. It allows you to push a new value onto an array that is already stored in the session.

php
$request->session()->push('user.teams', 'developers');

Distinction:

• put: Sets or overwrites a value for a specific key.
• push: Appends a value to an array associated with the key.

Retrieve and Delete (pull)

The pull method retrieves an item from the session and immediately removes it from the storage.

php
request->session()->pull('key', 'default');

Deleting Specific Items (forget)

The forget method removes a specific piece of data (or multiple pieces) from the session.

php
// Forget a single key
$request->session()->forget('key');

// Forget multiple keys
$request->session()->forget(['key1', 'key2']);

Deleting All Items (flush)

The flush method removes all data from the session.

php
$request->session()->flush();

Concept

Flash data refers to session data that is stored only for the immediate next request, after which it is automatically deleted.

Use Case

This is primarily used for short-lived status messages, such as displaying a "Task created successfully!" banner after a form submission redirects the user to a list page.

Implementation

Use the flash method on the session instance.

php
$request->session()->flash('status', 'Task was successful!');

In the subsequent request (e.g., in a Blade view), you check for it like normal session data:

html
@if (session('status'))
<div class="alert alert-success">
{{ session('status') }}
</div>
@endif

If you need to keep flash data for one more request (e.g., across multiple redirects), you can use the reflash or keep methods.

Importance

Regenerating the session ID is a critical security practice to prevent Session Fixation attacks. In such attacks, a malicious user fixes another user's session ID effectively hijacking the session.

By regenerating the ID (changing the underlying unique identifier string while keeping the session data) immediately after sensitive actions—like logging in—you ensure that any ID an attacker might possess becomes invalid.

Implementation in Laravel

Laravel automatically regenerates the session ID during authentication via its built-in auth controllers. However, if you are manually handling session logic, you can use the regenerate method.

php
$request->session()->regenerate();

This method generates a new session ID and invalidates the old one.

Laravel provides helpers to generate URLs for your application.

The url Helper

The url helper is used to generate arbitrary URLs for the application. It will automatically handle the HTTP/HTTPS protocol and the host definition.

php
$url = url('/posts');

// With current query parameters
$current = url()->current();

The route Helper

The route helper generates URLs for named routes. This is preferred because if the URL path changes in the definition (routes/web.php), you do not need to update your views or controllers, as long as the route name remains the same.

Route Definition:
php
Route::get('/user/profile', [UserProfileController::class, 'show'])->name('profile');

Generating URL:
php
$url = route('profile');

If the route accepts parameters:
php
$url = route('profile', ['id' => 1]);
// Result: http://your-app.com/user/profile?id=1 (or path param if defined)

When working with forms that contain arrays of inputs (e.g., <input name="products[0][name]">), Laravel allows you to access these values and check for their existence using "dot" notation.

Checking Existence

You can pass a string containing dots to the has method:

php
if ($request->has('products.0.name')) {
// The name of the first product exists
}

if ($request->has(['products.0.name', 'products.0.price'])) {
// Both exist
}

Retrieving Data

Similarly, you can retrieve the data using dot notation:

php
request->input('products.0.name');

You can also use the wildcard character * to retrieve data for all elements in the array:

php
request->input('products.*.name');
// Returns an array of names for all products

While both Cookies and Sessions are used to store data across requests, they differ significantly in implementation and use cases.