Image Body From Get Request as S3 Body for Upload
HTTP Requests
- Introduction
- Interacting With The Request
- Accessing The Request
- Request Path & Method
- Request Headers
- Request IP Address
- Content Negotiation
- PSR-vii Requests
- Input
- Retrieving Input
- Determining If Input Is Present
- Merging Additional Input
- Old Input
- Cookies
- Input Trimming & Normalization
- Files
- Retrieving Uploaded Files
- Storing Uploaded Files
- Configuring Trusted Proxies
- Configuring Trusted Hosts
Introduction
Laravel's Illuminate\Http\Request class provides an object-oriented way to interact with the current HTTP request being handled by your awarding also every bit think the input, cookies, and files that were submitted with the asking.
Interacting With The Request
Accessing The Request
To obtain an instance of the current HTTP asking via dependency injection, y'all should type-hint the Illuminate\Http\Request course on your road closure or controller method. The incoming request case will automatically exist injected by the Laravel service container:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\ Request ;
grade UserController extends Controller
{
/**
* Store a new user.
*
* @param \ Illuminate \ Http \ Request $request
* @return \ Illuminate \ Http \ Response
*/
public function store ( Request $asking )
{
$name = $request -> input ( ' name ' );
//
}
}
Equally mentioned, you may likewise type-hint the Illuminate\Http\Asking grade on a route closure. The service container will automatically inject the incoming asking into the closure when information technology is executed:
use Illuminate\Http\ Asking ;
Route :: get ( ' / ' , part ( Request $request ) {
//
});
Dependency Injection & Route Parameters
If your controller method is also expecting input from a road parameter you should list your route parameters after your other dependencies. For instance, if your route is defined like and so:
apply App\Http\Controllers\ UserController ;
Route :: put ( ' /user/{id} ' , [ UserController :: class , ' update ' ]);
Yous may however type-hint the Illuminate\Http\Request and access your id route parameter by defining your controller method equally follows:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\ Request ;
course UserController extends Controller
{
/**
* Update the specified user.
*
* @param \ Illuminate \ Http \ Request $request
* @param string $id
* @return \ Illuminate \ Http \ Response
*/
public function update ( Request $asking , $id )
{
//
}
}
Request Path & Method
The Illuminate\Http\Request instance provides a variety of methods for examining the incoming HTTP request and extends the Symfony\Component\HttpFoundation\Request class. We will hash out a few of the most important methods below.
Retrieving The Request Path
The path method returns the request's path data. And so, if the incoming request is targeted at http://example.com/foo/bar, the path method will render foo/bar:
$uri = $request -> path ();
Inspecting The Request Path / Route
The is method allows yous to verify that the incoming asking path matches a given blueprint. You may use the * character as a wildcard when utilizing this method:
if ( $request -> is ( ' admin/* ' )) {
//
}
Using the routeIs method, you may make up one's mind if the incoming request has matched a named route:
if ( $request -> routeIs ( ' admin.* ' )) {
//
}
Retrieving The Request URL
To retrieve the full URL for the incoming request you may utilize the url or fullUrl methods. The url method volition return the URL without the query string, while the fullUrl method includes the query string:
$url = $request -> url ();
$urlWithQueryString = $request -> fullUrl ();
If you would like to append query cord data to the current URL, yous may telephone call the fullUrlWithQuery method. This method merges the given array of query string variables with the electric current query string:
$asking -> fullUrlWithQuery ([ ' type ' => ' phone ' ]);
Retrieving The Request Method
The method method volition render the HTTP verb for the request. You may use the isMethod method to verify that the HTTP verb matches a given cord:
$method = $request -> method ();
if ( $request -> isMethod ( ' mail service ' )) {
//
}
Request Headers
You may call up a request header from the Illuminate\Http\Request example using the header method. If the header is not nowadays on the asking, zero will exist returned. All the same, the header method accepts an optional 2d argument that will be returned if the header is non nowadays on the request:
$value = $request -> header ( ' 10-Header-Name ' );
$value = $asking -> header ( ' X-Header-Name ' , ' default ' );
The hasHeader method may exist used to make up one's mind if the request contains a given header:
if ( $request -> hasHeader ( ' X-Header-Name ' )) {
//
}
For convenience, the bearerToken method may be used to recollect a bearer token from the Authority header. If no such header is present, an empty string will be returned:
$token = $request -> bearerToken ();
Asking IP Address
The ip method may be used to remember the IP address of the client that made the asking to your application:
$ipAddress = $request -> ip ();
Content Negotiation
Laravel provides several methods for inspecting the incoming asking'southward requested content types via the Accept header. First, the getAcceptableContentTypes method will return an array containing all of the content types accustomed by the request:
$contentTypes = $request -> getAcceptableContentTypes ();
The accepts method accepts an array of content types and returns true if whatsoever of the content types are accepted by the request. Otherwise, faux volition exist returned:
if ( $request -> accepts ([ ' text/html ' , ' application/json ' ])) {
// ...
}
You may utilise the prefers method to determine which content type out of a given array of content types is well-nigh preferred by the request. If none of the provided content types are accepted by the request, zero volition be returned:
$preferred = $request -> prefers ([ ' text/html ' , ' application/json ' ]);
Since many applications just serve HTML or JSON, you may apply the expectsJson method to apace determine if the incoming request expects a JSON response:
if ( $request -> expectsJson ()) {
// ...
}
PSR-vii Requests
The PSR-seven standard specifies interfaces for HTTP messages, including requests and responses. If you would similar to obtain an instance of a PSR-seven asking instead of a Laravel request, y'all will first demand to install a few libraries. Laravel uses the Symfony HTTP Bulletin Bridge component to catechumen typical Laravel requests and responses into PSR-7 compatible implementations:
composer crave symfony/psr-http-message-span
composer require nyholm/psr7
Once you have installed these libraries, yous may obtain a PSR-7 request by blazon-hinting the request interface on your route closure or controller method:
use Psr\Http\Message\ ServerRequestInterface ;
Road :: get ( ' / ' , function ( ServerRequestInterface $request ) {
//
});
{tip} If y'all return a PSR-7 response instance from a route or controller, it will automatically exist converted back to a Laravel response instance and be displayed by the framework.
Input
Retrieving Input
Retrieving All Input Data
You lot may call back all of the incoming request's input information as an array using the all method. This method may exist used regardless of whether the incoming request is from an HTML form or is an XHR request:
$input = $request -> all ();
Using the collect method, you may recall all of the incoming request's input data equally a collection:
$input = $request -> collect ();
The collect method too allows you to recall a subset of the incoming request input every bit a collection:
$request -> collect ( ' users ' ) -> each ( office ( $user ) {
// ...
});
Retrieving An Input Value
Using a few simple methods, y'all may access all of the user input from your Illuminate\Http\Request instance without worrying virtually which HTTP verb was used for the asking. Regardless of the HTTP verb, the input method may be used to retrieve user input:
$proper name = $request -> input ( ' name ' );
You may pass a default value equally the second statement to the input method. This value will be returned if the requested input value is not present on the asking:
$name = $request -> input ( ' name ' , ' Sally ' );
When working with forms that contain array inputs, use "dot" notation to access the arrays:
$name = $asking -> input ( ' products.0.name ' );
$names = $request -> input ( ' products.*.name ' );
Y'all may call the input method without any arguments in society to retrieve all of the input values as an associative array:
$input = $request -> input ();
Retrieving Input From The Query String
While the input method retrieves values from the entire asking payload (including the query string), the query method will merely think values from the query string:
$name = $request -> query ( ' name ' );
If the requested query string value data is not present, the second argument to this method volition be returned:
$name = $request -> query ( ' name ' , ' Helen ' );
You may phone call the query method without any arguments in order to recollect all of the query string values as an associative array:
$query = $asking -> query ();
Retrieving JSON Input Values
When sending JSON requests to your application, you lot may access the JSON information via the input method every bit long as the Content-Type header of the asking is properly gear up to application/json. Yous may even utilise "dot" syntax to retrieve values that are nested within JSON arrays:
$name = $request -> input ( ' user.proper noun ' );
Retrieving Boolean Input Values
When dealing with HTML elements similar checkboxes, your application may receive "truthy" values that are really strings. For example, "true" or "on". For convenience, yous may employ the boolean method to retrieve these values as booleans. The boolean method returns true for ane, "i", true, "truthful", "on", and "yeah". All other values will render false:
$archived = $request -> boolean ( ' archived ' );
Retrieving Date Input Values
For convenience, input values containing dates / times may be retrieved as Carbon instances using the date method. If the request does not contain an input value with the given name, zip will be returned:
$birthday = $asking -> appointment ( ' birthday ' );
The second and third arguments accepted by the date method may exist used to specify the engagement'due south format and timezone, respectively:
$elapsed = $asking -> date ( ' elapsed ' , ' !H:i ' , ' Europe/Madrid ' );
If the input value is nowadays merely has an invalid format, an InvalidArgumentException volition be thrown; therefore, it is recommended that you validate the input earlier invoking the date method.
Retrieving Input Via Dynamic Properties
You lot may besides access user input using dynamic properties on the Illuminate\Http\Request case. For case, if one of your application's forms contains a proper name field, yous may access the value of the field similar so:
$name = $request ->name ;
When using dynamic backdrop, Laravel volition first await for the parameter'southward value in the request payload. If it is not present, Laravel will search for the field in the matched route'south parameters.
Retrieving A Portion Of The Input Data
If you lot need to retrieve a subset of the input information, yous may apply the only and except methods. Both of these methods have a unmarried assortment or a dynamic list of arguments:
$input = $request -> only ([ ' username ' , ' countersign ' ]);
$input = $request -> but ( ' username ' , ' countersign ' );
$input = $request -> except ([ ' credit_card ' ]);
$input = $request -> except ( ' credit_card ' );
{note} The
onlymethod returns all of the key / value pairs that you lot request; however, it will non render key / value pairs that are not present on the asking.
Determining If Input Is Nowadays
You lot may use the has method to determine if a value is nowadays on the request. The has method returns truthful if the value is present on the asking:
if ( $request -> has ( ' proper noun ' )) {
//
}
When given an array, the has method will determine if all of the specified values are present:
if ( $asking -> has ([ ' name ' , ' email ' ])) {
//
}
The whenHas method volition execute the given closure if a value is nowadays on the request:
$request -> whenHas ( ' proper name ' , function ( $input ) {
//
});
A 2d closure may be passed to the whenHas method that will be executed if the specified value is non present on the asking:
$request -> whenHas ( ' name ' , function ( $input ) {
// The "name" value is present...
}, office () {
// The "name" value is not present...
});
The hasAny method returns truthful if whatsoever of the specified values are nowadays:
if ( $request -> hasAny ([ ' proper name ' , ' electronic mail ' ])) {
//
}
If yous would like to make up one's mind if a value is present on the request and is not empty, you lot may use the filled method:
if ( $asking -> filled ( ' proper name ' )) {
//
}
The whenFilled method volition execute the given closure if a value is present on the asking and is not empty:
$request -> whenFilled ( ' name ' , office ( $input ) {
//
});
A second closure may be passed to the whenFilled method that will be executed if the specified value is not "filled":
$request -> whenFilled ( ' name ' , function ( $input ) {
// The "name" value is filled...
}, function () {
// The "name" value is not filled...
});
To determine if a given key is absent from the request, you may use the missing method:
if ( $request -> missing ( ' name ' )) {
//
}
Merging Boosted Input
Sometimes you lot may need to manually merge additional input into the request's existing input data. To reach this, you may employ the merge method:
$asking -> merge ([ ' votes ' => 0 ]);
The mergeIfMissing method may be used to merge input into the request if the corresponding keys exercise not already be inside the asking's input data:
$asking -> mergeIfMissing ([ ' votes ' => 0 ]);
Onetime Input
Laravel allows you to keep input from 1 asking during the adjacent request. This feature is particularly useful for re-populating forms later detecting validation errors. All the same, if you lot are using Laravel's included validation features, it is possible that you will not need to manually utilize these session input flashing methods straight, as some of Laravel's built-in validation facilities will phone call them automatically.
Flashing Input To The Session
The flash method on the Illuminate\Http\Asking class will flash the electric current input to the session so that information technology is available during the user'due south next request to the application:
$asking -> flash ();
You may also use the flashOnly and flashExcept methods to flash a subset of the request data to the session. These methods are useful for keeping sensitive information such equally passwords out of the session:
$request -> flashOnly ([ ' username ' , ' email ' ]);
$request -> flashExcept ( ' password ' );
Flashing Input And so Redirecting
Since yous often will desire to flash input to the session and and so redirect to the previous page, you may hands chain input flashing onto a redirect using the withInput method:
return redirect ( ' course ' ) -> withInput ();
return redirect () -> route ( ' user.create ' ) -> withInput ();
return redirect ( ' grade ' ) -> withInput (
$request -> except ( ' password ' )
);
Retrieving Old Input
To retrieve flashed input from the previous request, invoke the old method on an example of Illuminate\Http\Request. The former method will pull the previously flashed input data from the session:
$username = $asking -> old ( ' username ' );
Laravel also provides a global onetime helper. If you are displaying one-time input inside a Bract template, it is more user-friendly to use the old helper to repopulate the form. If no erstwhile input exists for the given field, null will be returned:
< input type = " text " name = " username " value = " {{ old('username') }} " >
Cookies
Retrieving Cookies From Requests
All cookies created past the Laravel framework are encrypted and signed with an hallmark code, meaning they will be considered invalid if they have been changed by the client. To retrieve a cookie value from the asking, utilise the cookie method on an Illuminate\Http\Request example:
$value = $asking -> cookie ( ' proper name ' );
Input Trimming & Normalization
Past default, Laravel includes the App\Http\Middleware\TrimStrings and App\Http\Middleware\ConvertEmptyStringsToNull middleware in your awarding'south global middleware stack. These middleware are listed in the global middleware stack by the App\Http\Kernel class. These middleware will automatically trim all incoming string fields on the asking, too as catechumen any empty cord fields to null. This allows you to not have to worry nearly these normalization concerns in your routes and controllers.
If y'all would like to disable this behavior, you may remove the two middleware from your application's middleware stack by removing them from the $middleware property of your App\Http\Kernel course.
Files
Retrieving Uploaded Files
Yous may call up uploaded files from an Illuminate\Http\Request instance using the file method or using dynamic properties. The file method returns an instance of the Illuminate\Http\UploadedFile form, which extends the PHP SplFileInfo class and provides a variety of methods for interacting with the file:
$file = $asking -> file ( ' photo ' );
$file = $asking ->photo ;
You may make up one's mind if a file is present on the request using the hasFile method:
if ( $request -> hasFile ( ' photograph ' )) {
//
}
Validating Successful Uploads
In add-on to checking if the file is present, y'all may verify that there were no issues uploading the file via the isValid method:
if ( $request -> file ( ' photograph ' ) -> isValid ()) {
//
}
File Paths & Extensions
The UploadedFile class as well contains methods for accessing the file's fully-qualified path and its extension. The extension method volition try to guess the file's extension based on its contents. This extension may be different from the extension that was supplied by the client:
$path = $request ->photo-> path ();
$extension = $asking ->photo-> extension ();
Other File Methods
There are a variety of other methods available on UploadedFile instances. Check out the API documentation for the class for more data regarding these methods.
Storing Uploaded Files
To shop an uploaded file, y'all will typically use one of your configured filesystems. The UploadedFile form has a shop method that will motion an uploaded file to one of your disks, which may exist a location on your local filesystem or a deject storage location like Amazon S3.
The shop method accepts the path where the file should be stored relative to the filesystem's configured root directory. This path should not contain a filename, since a unique ID will automatically be generated to serve as the filename.
The store method also accepts an optional second argument for the name of the disk that should be used to store the file. The method will return the path of the file relative to the disk's root:
$path = $asking ->photograph-> shop ( ' images ' );
$path = $request ->photo-> shop ( ' images ' , ' s3 ' );
If you do not desire a filename to be automatically generated, you may employ the storeAs method, which accepts the path, filename, and disk name every bit its arguments:
$path = $request ->photo-> storeAs ( ' images ' , ' filename.jpg ' );
$path = $request ->photo-> storeAs ( ' images ' , ' filename.jpg ' , ' s3 ' );
{tip} For more information about file storage in Laravel, cheque out the complete file storage documentation.
Configuring Trusted Proxies
When running your applications behind a load balancer that terminates TLS / SSL certificates, you may notice your awarding sometimes does non generate HTTPS links when using the url helper. Typically this is because your awarding is being forwarded traffic from your load balancer on port lxxx and does not know it should generate secure links.
To solve this, you may employ the App\Http\Middleware\TrustProxies middleware that is included in your Laravel application, which allows you to quickly customize the load balancers or proxies that should be trusted past your awarding. Your trusted proxies should exist listed as an array on the $proxies property of this middleware. In improver to configuring the trusted proxies, yous may configure the proxy $headers that should exist trusted:
<?php
namespace App\Http\Middleware;
use Illuminate\Http\Middleware\ TrustProxies as Middleware;
utilize Illuminate\Http\ Asking ;
class TrustProxies extends Middleware
{
/**
* The trusted proxies for this application.
*
* @var string | assortment
*/
protected $proxies = [
' 192.168.1.1 ' ,
' 192.168.1.ii ' ,
];
/**
* The headers that should be used to detect proxies.
*
* @var int
*/
protected $headers = Request :: HEADER_X_FORWARDED_FOR | Request :: HEADER_X_FORWARDED_HOST | Asking :: HEADER_X_FORWARDED_PORT | Request :: HEADER_X_FORWARDED_PROTO ;
}
{tip} If you lot are using AWS Elastic Load Balancing, your
$headersvalue should existRequest::HEADER_X_FORWARDED_AWS_ELB. For more information on the constants that may be used in the$headersbelongings, check out Symfony's documentation on trusting proxies.
Trusting All Proxies
If you are using Amazon AWS or another "cloud" load balancer provider, y'all may not know the IP addresses of your actual balancers. In this instance, you may use * to trust all proxies:
/**
* The trusted proxies for this application.
*
* @var string | array
*/
protected $proxies = ' * ' ;
Configuring Trusted Hosts
By default, Laravel will respond to all requests it receives regardless of the content of the HTTP request's Host header. In improver, the Host header's value will be used when generating absolute URLs to your application during a web request.
Typically, you lot should configure your web server, such as Nginx or Apache, to only send requests to your application that match a given host name. However, if yous practise not have the power to customize your web server directly and need to instruct Laravel to only respond to certain host names, you may do so by enabling the App\Http\Middleware\TrustHosts middleware for your application.
The TrustHosts middleware is already included in the $middleware stack of your application; however, you should uncomment it so that it becomes agile. Inside this middleware'due south hosts method, you may specify the host names that your awarding should respond to. Incoming requests with other Host value headers will be rejected:
/**
* Become the host patterns that should be trusted.
*
* @return assortment
*/
public function hosts ()
{
return [
' laravel.test ' ,
$this -> allSubdomainsOfApplicationUrl (),
];
}
The allSubdomainsOfApplicationUrl helper method will return a regular expression matching all subdomains of your application's app.url configuration value. This helper method provides a convenient way to allow all of your application's subdomains when building an application that utilizes wildcard subdomains.
Source: https://laravel.com/docs/9.x/requests
0 Response to "Image Body From Get Request as S3 Body for Upload"
Post a Comment