Proxy.php

<?php

namespace App\Services;

use Illuminate\Http\Client\PendingRequest;
use Illuminate\Http\Client\Response;
use Illuminate\Http\Request;
use Illuminate\Http\UploadedFile as HttpUploadedFile;
use Illuminate\Support\Facades\Http;

//https://raw.githubusercontent.com/jespanag/Laravel-Proxy-Helper/master/ProxyHelper.php
class Proxy {

    //Original request
    private Request $originalRequest;
    //Params from multipart requests
    private $multipartParams;
    //Custom Headers
    private $headers;
    //Custom Authorization
    private $authorization;
    //Custom Method
    private $customMethod;

    private $addQuery;

    private $cookies;
    private string $cookieDomain;

    //Settings
    private $useDefaultAuth;


    public static function createProxy(Request $request, $useDefaultAuth = true):Proxy
    {
        $obj = new Proxy();
        $obj->originalRequest = $request;
        $obj->multipartParams = $obj->GetMultipartParams();
        $obj->useDefaultAuth = $useDefaultAuth;

        return $obj;
    }

    public function withHeaders($headers){
        $this->headers = $headers;
        return $this;
    }

    public function withCookies($cookies,?string $cookieDomain = null ){
        $this->cookies = $cookies;
        if( $cookieDomain ){
            $this->cookieDomain = $cookieDomain;
        }else {
            $this->cookieDomain = config('app.url');
        }
        return $this;
    }

    public function withBasicAuth($user, $secret){
        $this->authorization = ['type' => 'basic', 'user' => $user, 'secret' => $secret ];
         return $this;
    }

    public function withDigestAuth($user, $secret){
        $this->authorization = ['type' => 'digest', 'user' => $user, 'secret' => $secret ];
        return $this;
     }

    public function withToken($token){
        $this->authorization = ['type' => 'token', 'token' => $token ];
        return $this;
     }

    public function withMethod($method = 'POST'){
        $this->customMethod = $method; return $this;
     }

    public function preserveQuery($preserve){
        $this->addQuery = $preserve;
        return $this; }

    public function getResponse($url){

        $info = $this->getRequestInfo();

        $http = $this->createHttp($info['type']);
        $http = $this->setAuth($http, $info['token']);
        $http = $this->setHeaders($http);
        $http = $this->setCookies($http);

        if($this->addQuery && $info['query'])
            $url = $url.'?'.http_build_query($info['query']);

        $response = $this->call($http, $info['method'], $url, $this->getParams($info));

        return response($this->isJson($response) ? $response->json() : $response->body(), $response->status());
    }

    public function toUrl($url){
        return $this->getResponse($url);
     }

    public function toHost($host, $proxyController){
        return $this->getResponse($host.str_replace($proxyController, '', $this->originalRequest->path()));
    }

    private function getParams($info){
        $defaultParams = [];
        if($info['method'] == 'GET')
            return $info['params'];
        if($info['type'] == 'multipart')
            $defaultParams = $this->multipartParams;
        else
            $defaultParams = $info['params'];
        if($info['query'])
            foreach ($info['query'] as $key => $value)
                unset($defaultParams[array_search(['name' => $key,'contents' => $value], $defaultParams)]);
        return $defaultParams;
    }

    private function setAuth(PendingRequest $request, $currentAuth = null){
        if(!$this->authorization){
            return $request;
        }
        switch ($this->authorization['type']) {
            case 'basic':
                return $request->withBasicAuth($this->authorization['user'],$this->authorization['secret']);
            case 'digest':
                return $request->withDigestAuth($this->authorization['user'],$this->authorization['secret']);
            case 'token':
                return $request->withToken($this->authorization['token']);
            default:
                if($currentAuth && $this->useDefaultAuth)
                    return $request->withToken($currentAuth);
                return $request;
        }
    }

    private function setHeaders(PendingRequest $request):PendingRequest
    {
        if(!$this->headers){
            return $request;

        }
        return $request->withHeaders($this->headers);
    }

    private function setCookies(PendingRequest $request):PendingRequest
    {
        if(!$this->cookies){
            return $request;

        }
        return $request->withCookies($this->cookies,$this->cookieDomain);
    }

    private function createHttp($type){
        switch ($type) {
            case 'multipart':
                return Http::asMultipart();
            case 'form':
                return Http::asForm();
            case 'json':
                return Http::asJson();
            case null:
                return new PendingRequest();
            default:
                return Http::contentType($type);
        }
    }

    private function call(PendingRequest $request, $method, $url, $params){
        if($this->customMethod)
            $method = $this->customMethod;
        switch ($method) {
            case 'GET':
                return $request->get($url, $params);
            case 'HEAD':
                return $request->head($url, $params);
            default:
            case 'POST':
                return $request->post($url, $params);
            case 'PATCH':
                return $request->patch($url, $params);
            case 'PUT':
                return $request->put($url, $params);
            case 'DELETE':
                return $request->delete($url, $params);
        }
    }

    private function getRequestInfo(){
        return [
            'type' => ($this->originalRequest->isJson() ? 'json' :
                    (strpos($this->originalRequest->header('Content-Type'),'multipart') !== false ? 'multipart' :
                    ($this->originalRequest->header('Content-Type') == 'application/x-www-form-urlencoded' ? 'form' : $this->originalRequest->header('Content-Type')))),
            'agent' => $this->originalRequest->userAgent(),
            'method' => $this->originalRequest->method(),
            'token' => $this->originalRequest->bearerToken(),
            'full_url'=>$this->originalRequest->fullUrl(),
            'url'=>$this->originalRequest->url(),
            'format'=>$this->originalRequest->format(),
            'query' =>$this->originalRequest->query(),
            'params' => $this->originalRequest->all(),
        ];
    }

    private function GetMultipartParams(){
        $multipartParams = [];
        if ($this->originalRequest->isMethod('post')) {
            $formParams = $this->originalRequest->all();
            $fileUploads = [];
            foreach ($formParams as $key => $param)
                if ($param instanceof HttpUploadedFile) {
                  $fileUploads[$key] = $param;
                  unset($formParams[$key]);
                }
            if (count($fileUploads) > 0){
                $multipartParams = [];
                foreach ($formParams as $key => $value)
                    $multipartParams[] = [
                      'name' => $key,
                      'contents' => $value
                    ];
                foreach ($fileUploads as $key => $value)
                    $multipartParams[] = [
                      'name' => $key,
                      'contents' => fopen($value->getRealPath(), 'r'),
                      'filename' => $value->getClientOriginalName(),
                      'headers' => [
                        'Content-Type' => $value->getMimeType()
                      ]
                    ];
            }
        }
        return $multipartParams;
    }

    private function isJson(Response $response){
        return strpos($response->header('Content-Type'),'json') !== false;
    }
}