# Requests

## Introduction

The Request class is initialized when the server first starts and is modified on every request. This means that the Request class acts as a singleton and is not reinitialized on every request. This presents both pros and cons during developing Masonite. It's great to not have to worry about a new object being instantiated every time but the con is that some attributes need to be reset at the end of the request.

The Request class is loaded into the IOC container first so any Service Provider will have access to it. The IOC container allows all parts of the framework to be resolved by the IOC container and auto inject any dependencies they need.

{% hint style="success" %}
Read more about the IOC container in the [Service Container](https://docs.masoniteproject.com/v2.1/architectural-concepts/service-container) documentation.
{% endhint %}

## Getting Started

The Request class is bound into the IOC container once when the server is first started. This takes the WSGI environment variables generated by your WSGI server as a parameter. Because of this, we reload the WSGI values on every request but the actual Request object does not change. In other words, the memory address of the Request object is always the same but the class attributes will change of every request. This is done already for you by the Masonite framework itself. This Request class is bound and initialized inside the `AppProvider` Service Provider. We grab this request object by simply passing in `Request` into the parameters of anything resolved by the Service Container such as middleware, drivers and controller methods like so:

```python
def show(self, request: Request):
    request #== <masonite.request.Request>
```

Masonite is smart enough to know that we need the `Request` class and it will inject it into our method for us.

## **Helper Function**

Masonite ships with a `HelpersProvider` Service Provider which adds several helper functions. One of these helper functions is the `request()` function. This function will return the request object. Because of this, these two pieces of code are identical:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    request.input('username')
```

{% endcode %}

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self):
    request().input('username')
```

{% endcode %}

Notice we didn't import anything at the top of our file and also didn't retrieve any objects from the IOC container. Masonite helper functions act just like any other built in Python function.

{% hint style="success" %}
Read more about helper functions in the [Helper Functions](https://docs.masoniteproject.com/v2.1/the-basics/helper-functions) documentation.
{% endhint %}

## Usage

The `Request` has several helper methods attached to it in order to interact with various aspects of the request.

In order to get the current request input variables such as the form data during a `POST` request or the query string during a `GET` request looks like:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    request.input('username')
```

{% endcode %}

{% hint style="info" %}
There is no difference between any HTTP methods (GET, POST, PUT, etc) when it comes to getting input data. They are all retrieved through this `.input()` method so there is no need to make a distinction if the request is `GET` or `POST`
{% endhint %}

## Method Options

### Input Data

We can get all the request input variables such as input data from a form request or GET data from a query string. Note that it does not matter what HTTP method you are using, the input method will know what input data to get dependent on the current HTTP method (`GET`, `POST`, `PUT`, etc)

This will return all the available request input variables for that request as a dictionary.

{% code title="app/http/controllers/YourController.py" %}

```python
# GET: /dashboard?user=Joe&status=1

def show(self, request: Request):
    return request.all() # {'user': 'Joe', 'status': '1'}
```

{% endcode %}

This method will get all of the request input variables to include any internal framework variables completely handled internally such as \_\_token and \_\_method. You can exclude them by passing in False into the method or specifying it explicitly:

{% code title="app/http/controllers/YourController.py" %}

```python
# GET: /dashboard?user=Joe&status=1&__token=837674634

def show(self, request: Request):
    return request.all(internal_variables=False) # {'user': 'Joe', 'status': '1'}
```

{% endcode %}

To get a specific input:

{% code title="app/http/controllers/YourController.py" %}

```python
# GET: /dashboard?firstname=Joe

def show(self, request: Request):
    return request.input('firstname') # Joe
```

{% endcode %}

#### Input Cleaning

Input data will be cleaned of HTML tags and other security measures. This may cause unwanted return values if you are expecting something like a JSON string. If you want to opt to not clean the input you can specify that as a keyword argument:

{% code title="app/http/controllers/YourController.py" %}

```python
request.input('firstname', clean=False) # Joe
```

{% endcode %}

To check if some request input data exists:

{% code title="app/http/controllers/YourController.py" %}

```python
# GET: /dashboard?firstname=Joe

def show(self, request: Request):
    return request.has('firstname') # True
```

{% endcode %}

#### Getting Dictionary Input

If your input is a dictionary you have two choices how you want to access the dictionary. You can either access it normally:

{% code title="app/http/controllers/YourController.py" %}

```python
request.input('payload')['user']['address'] # 123 Smith Rd
```

{% endcode %}

Or you can use dot notation to fetch the value for simplicity:

{% code title="app/http/controllers/YourController.py" %}

```python
request.input('payload.user.address') # 123 Smith Rd
```

{% endcode %}

### Only

You can only get a certain set of parameters if you have a need to do so. This can be used like:

{% code title="app/http/controllers/YourController.py" %}

```python
# GET: /dashboard?firstname=Joe&lastname=Mancuso&active=1

def show(self, request: Request):
    return request.only('firstname', 'active') # {'firstname': 'Joe', 'active': '1'}
```

{% endcode %}

### Without

We can specify a set of parameters to exclude from the inputs returned. For example:

```python
# GET: /dashboard?firstname=Joe&lastname=Mancuso&active=1

def show(self, request: Request):
    return request.without('lastname') # {'firstname': 'Joe', 'active': '1'}
```

Notice it returned everything besides `lastname`.

### URL Parameters

To get the request parameter retrieved from the url. This is used to get variables inside: `/dashboard/@firstname` for example.

{% code title="app/http/controllers/YourController.py" %}

```python
# Route: /dashboard/@firstname
# GET: /dashboard/Joe

def show(self, request: Request):
    return request.param('firstname') # Joe
```

{% endcode %}

## JSON Payloads

Sometimes you may want to handle incoming JSON requests. This could be form external API's like Github.

Masonite will detect that an incoming request is a JSON request and put the cast the JSON to a dictionary and load it into the payload request input. For example if you have an incoming request of:

{% code title="incoming request" %}

```javascript
{
    "name": "Joe",
    "email": "Joe@email.com"
}
```

{% endcode %}

Then we can fetch this input in a controller using the normal `input()` method like so:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    request.input('name') # Joe
```

{% endcode %}

## Cookies

You may also set a cookie in the browser. The below code will set a cookie named `key` to the value of `value`.

{% hint style="warning" %}
By default, all cookies are encrypted with your secret key which is generated in your `.env` file when you installed Masonite. This is a security measure to ensure malicious Javascript code cannot fetch cookies if they are somehow retrieved. All cookies are set with the HTTP\_ONLY flag meaning that Javascript cannot read them although you can turn this off using a parameter.
{% endhint %}

### **Creating**

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.cookie('key', 'value')
```

{% endcode %}

#### Not Encrypting

If you choose to not encrypt your values and create cookies with the plain text value then you can pass a third value of `True` or `False`. You can also be more explicit if you like:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.cookie('key', 'value', encrypt=False)
```

{% endcode %}

#### Expirations

All cookies are set as session cookies. This means that when the user closes out the browser completely, all cookies will be deleted.

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.cookie('key', 'value', expires="5 minutes")
```

{% endcode %}

This will set a cookie thats expires 5 minutes from the current time.

#### HttpOnly

Again, as a security measure, all cookies automatically are set with the `HttpOnly` flag which makes it unavailable to any Javascript code. You can turn this off:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.cookie('key', 'value', http_only=False)
```

{% endcode %}

This will now allow Javascript to read the cookie.

### **Reading**

You can get all the cookies set from the browser

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.get_cookies()
```

{% endcode %}

You can get a specific cookie set from the browser

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.get_cookie('key')
```

{% endcode %}

Again, all cookies are encrypted by default so if you set a cookie with encryption then this method will decrypt the cookie. If you set a cookie in plain text then you should pass the `False` as the second parameter here to tell Masonite not to decrypt your plain text cookie value.:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.get_cookie('key', decrypt=False)
```

{% endcode %}

This will return the plain text version of the cookie.

{% hint style="warning" %}
If Masonite attempts to decrypt a cookie but cannot then Masonite will assume that the secret key that encrypted it was changed or the cookie has been tampered with and will delete the cookie completely.

If your secret key has been compromised then you may change the key at anytime and all cookies set on your server will be removed.
{% endhint %}

### **Deleting**

You may also delete a cookie. This will remove it from the browser.

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.delete_cookie('key')
```

{% endcode %}

## User

You can also get the current user from the request. This requires the `LoadUserMiddleware` middleware which is in Masonite by default. This will return an instance of the current user.

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.user()
```

{% endcode %}

## Routes

You can also get a route URL via the route name. Let's say we have a route like this:

```python
get('/dashboard').name('dashboard')
```

We can get the URL from the route name like so:

```python
def show(self):
    request().route('dashboard') # /dashboard
```

### Route Parsing

if we have route parameters like this:

```python
get('/dashboard/@user').name('dashboard.user')
```

then we can pass in a dictionary:

```python
def show(self):
    request().route('dashboard.user', {'user': 1}) # /dashboard/1
```

You may also pass a list if that makes more sense to you:

```python
def show(self):
    request().route('dashboard.user', [1]) # /dashboard/1
```

This will inject that value for each parameter in order. For example if we have this route:

```python
get('/dashboard/@user/@id/@slug').name('dashboard.user')
```

then we can use:

```python
def show(self):
    request().route('dashboard.user', [1, 2, 'some-slug']) 
    # /dashboard/1/2/some-slug
```

## Current URL

We can get the current url with:

```python
def show(self, request: Request):
    return request.path #== /dashboard/user
```

## Redirection

You can specify a url to redirect to

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect('/home')
```

{% endcode %}

If the url contains `http` than the route will redirect to the external website

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect('http://google.com')
```

{% endcode %}

You can redirect to a named route

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect_to('dashboard')
```

{% endcode %}

You can also use the name parameter on the redirect method:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect(name="dashboard")
```

{% endcode %}

You can also redirect to a specific controller. This will find the URL that is attached to the controller method

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect(controller="WelcomeController@show")
```

{% endcode %}

Sometimes your routes may require parameters passed to it such as redirecting to a route that has a url like: `/url/@firstname:string/@lastname:string`.

Redirecting to a named route with URL parameters:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect_to('dashboard', {'firstname': 'Joseph', 'lastname': 'Mancuso'})
```

{% endcode %}

Redirecting to a url in your application with URL parameters:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.redirect('dashboard/@id', {'id': '1'})
```

{% endcode %}

## Redirecting Back

There will be plenty of times you will need to redirect back to where the user came just came from. In order for this work we will need to specify where we need to go back to. We can use the back method for this.

There are 3 states which we should be aware of when using this method.

### Form Back Redirection

Masonite will check for a `__back` input and redirect to that route. We can specify one using the `back()` view helper function:

```markup
<form action="{{ route('dashboard.create') }}" method="POST">
    {{ csrf_field }}
    {{ back(request().path) }}
</form>
```

This will route back to the form when you run this back method

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.back() # uses value from the back() method helper
```

{% endcode %}

### No Input

The next state is using the back method without any parameters or form helpers:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.back() # defaults to current route
```

{% endcode %}

This will redirect back to the current route. This might be useful we have have routes like:

```python
ROUTES = [
    get('/dashboard/create', 'Controller@show'),
    post('/dashboard/create', 'Controller@store')
]
```

Where we are going to the `POST` version but want to redirect back to the `GET` version of the route.

### Default Back URL

We can also specify a default route just in case a form submitted does not specify one using a form helper:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    return request.back(default='/hit/route')
```

{% endcode %}

This will check for the `__back` input and if it doesn't exist it will use this default route.

## Encryption Key

You can load a specific secret key into the request by using:

```python
request.key(key)
```

This will load a secret key into the request which will be used for encryptions purposes throughout your Masonite project.

{% hint style="warning" %}
Note that by default, the secret key is pulled from your configuration file so you do NOT need to supply a secret key, but the option is there if you need to change it for testing and development purposes.
{% endhint %}

## Headers

You can also get and set any headers that the request has.

You can get all WSGI information by printing:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    print(request.environ)
```

{% endcode %}

This will print the environment setup by the WSGI server. Use this for development purposes.

You can also get a specific header:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    request.header('AUTHORIZATION')
```

{% endcode %}

This will return whatever the `HTTP_AUTHORIZATION` header if one exists. If that does not exist then the `AUTHORIZATION` header will be returned. If that does not exist then `None` will be returned.

We can also set headers:

{% code title="app/http/controllers/YourController.py" %}

```python
def show(self, request: Request):
    request.header('AUTHORIZATION', 'Bearer some-secret-key')
```

{% endcode %}

{% hint style="warning" %}
Masonite will automatically prepend a `HTTP_` to the header being set for standards purposes so this will set the `HTTP_AUTHORIZATION` header. If you do not want the `HTTP` prefix then pass a third parameter:
{% endhint %}

{% code title="app/http/controllers/YourController.py" %}

```python
request.header('AUTHORIZATION', 'Bearer some-secret-key')
```

{% endcode %}

This will set the `AUTHORIZATION` header **instead** of the `HTTP_AUTHORIZATION` header.

You can also set headers with a dictionary:

```python
request.header({
    'AUTHORIZATION': 'Bearer some-secret-key',
    'Content-Type': 'application/json'
})
```

## Status Codes

Masonite will set a status code of `404 Not Found` at the beginning of every request. If the status code is not changed throughout the code, either through the developer or third party packages, as it passes through each Service Provider then the status code will continue to be `404 Not Found` when the output is generated. You do not have to explicitly specify this as the framework itself handles status codes. If a route matches and your controller method is about to be hit then Masonite will set `200 OK` and hit your route. This allows Masonite to specify a good status code but also allows you to change it again inside your controller method.

You could change this status code in either any of your controllers or even a third party package via a Service Provider.

For example, the Masonite Entry package sets certain status codes upon certain actions on an API endpoint. These can be `429 Too Many Requests` or `201 Created`. These status codes need to be set before the `StartProvider` is ran so if you have a third party package that sets status codes or headers, then they will need to be placed above this Service Provider in a project.

If you are not specifying status codes in a package and simple specifying them in a controller then you can do so freely without any caveats. You can set status codes like so:

```python
request.status('429 Too Many Requests')
```

You can also use an integer which will find the correct status code for you:

```python
request.status(429)
```

This snippet is exactly the same as the string based snippet above.

This will set the correct status code before the output is sent to the browser. You can look up a list of HTTP status codes from an online resource and specify any you need to. There are no limitations to which ones you can use.

## Get Request Method Type

You can get the request method simply:

{% code title="app/http/controllers/YourController.py" %}

```python
# PUT: /dashboard

def show(self, request: Request):
    return request.get_request_method() # 'PUT'
```

{% endcode %}

## Changing Request Methods in Forms

Typically, forms only have support for `GET` and `POST`. You may want to change what HTTP method is used when submitting a form such as `PATCH`.

This will look like:

{% code title="resources/templates/index.html" %}

```markup
<form action="/dashboard" method="POST">
    <input type="hidden" name="request_method" value="PATCH">
</form>
```

{% endcode %}

or you can optionally use a helper method:

{% code title="resources/templates/index.html" %}

```markup
<form action="/dashboard" method="POST">
    {{ request_method('PATCH') }}
</form>
```

{% endcode %}

When the form is submitted, it will process as a PUT request instead of a POST request.

This will allow this form to hit a route like this:

{% code title="routes/web.py" %}

```python
from masonite.routes import Patch

ROUTES = [
    Patch().route('/dashboard', 'DashboardController@update')
]
```

{% endcode %}