Responsável por mandar Inclusão de Conta a pagar para Serviço da Rovereti
@param string $uri
@param MovimentoContaCorrente $movtoContaCorrente
@return Response
504819
public function execute(string $uri, MovimentoContaCorrente $movtoContaCorrente)
    {
        return $this->send(self::POST_METHOD, $uri, $movtoContaCorrente->toArray());
    }
71909
public function any( $uri, $action = null )
	{
		$verbs = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'];

		return $this->addRoute( $verbs, $uri, $action );
	}
69163
public static function get($uri)
	{
		return self::where('uri','=',$uri)
			->where('status','=',Page::APPROVED)
			->where('published_date','<=',\Carbon\Carbon::now())
			->first();
	}
109091
public function resolve(UriInterface $uri): UriInterface
    {
        $request = new Request('GET', $uri);
        $lastRequestUri = $request->getUri();
        $requestUri = new Uri('');

        try {
            $response = $this->httpClient->send($request, [
                'on_stats' => function (TransferStats $stats) use (&$requestUri) {
                    if ($stats->hasResponse()) {
                        $requestUri = $stats->getEffectiveUri();
                    }
                },
            ]);
        } catch (TooManyRedirectsException $tooManyRedirectsException) {
            return $requestUri;
        } catch (BadResponseException $badResponseException) {
            $response = $badResponseException->getResponse();
        }

        if ($this->followMetaRedirects) {
            $metaRedirectUri = $this->getMetaRedirectUriFromResponse($response, $lastRequestUri);

            if (!empty($metaRedirectUri) && !$this->isLastResponseUrl($metaRedirectUri, $lastRequestUri)) {
                return $this->resolve($metaRedirectUri);
            }
        }

        return $requestUri;
    }
79001
function requestURI( $uri )
    {
        $parsed = parse_url( $uri );

        $return = '';
        if ( isset( $parsed['user'] ) )
        {
            $return .= $parsed['user'] . '@' . $parsed['pass'];
        }
        $return .= rtrim( $parsed['path'], '/' ) . '/' . $this->Name;

        if ( isset( $parsed['query'] ) )
        {
            $return  .= '?' . $parsed['query'];
        }
        if ( isset( $parsed['fragment'] ) )
        {
            $return .= '#' . $parsed['fragment'];
        }

        return $return;
    }
6966
public function dispatch($method, $uri)
    {
        $routeInfo = $this->dispatcher->dispatch($method, $uri);

        if($routeInfo[0] === Dispatcher::NOT_FOUND) {

            $this->filterRequest('*', $method);

            $routeInfo = $this->dispatcher->dispatch($method, '*');

            if(!$routeInfo[0]) {
                throw new Exception("Route [ {$uri} ] not found.");
            }
        }

        if($routeInfo[0] === Dispatcher::METHOD_NOT_ALLOWED) {
            $method = $_SERVER['REQUEST_METHOD'];
            throw new Exception("[ $method ] method not allowed.");
        }

        if($routeInfo[0] === Dispatcher::FOUND) {
            $handler = $routeInfo[1];
            $params = $routeInfo[2];

            if(!empty($filterResponse = $this->filterRequest($uri, $method))) {
                return $filterResponse;
            }

            return $this->methodDispatcher($handler, $params);
        }
    }
866359
public function read(string $uri): Response
    {
        $contents = @file_get_contents($uri);

        if (false === $contents) {
            throw new ResourceNotReadableException("Failed reading '$uri'");
        }

        return new Response(
            preg_match('/\b(yml|yaml|raml)\b/', $uri) ? self::CONTENT_TYPE_YAML : self::CONTENT_TYPE_JSON,
            $contents
        );
    }
198706
public function dispatch($httpMethod, $uri)
    {
        list($handler, $filters, $vars) = $this->dispatchRoute($httpMethod, trim($uri, '/'));

        list($beforeFilter, $afterFilter) = $this->parseFilters($filters);

        if (($response = $this->dispatchFilters($beforeFilter)) !== null) {
            return $response;
        }

        $resolvedHandler = $this->handlerResolver->resolve($handler);
        $vars['request'] = $this->getRequest();
        $reflection = new ReflectionMethod($resolvedHandler[0], $resolvedHandler[1]);
        $reflectionVariables = $this->getReflectionVars($reflection, $vars);
        $this->authorizeRequest();
        $this->validateRequest($reflectionVariables);
        $response = call_user_func_array(
            $resolvedHandler,
            $reflectionVariables
        );

        return $this->dispatchFilters($afterFilter, $response);
    }
975372
public function respondsWithSuccess(string $message, string $redirectTo = '')
    {
        return response()->json([
            'redirectTo' => $redirectTo,
            'callback' => $redirectTo,
            'message' => $message,
            'success' => true,
        ], 200);
    }
275980
private function getMetaRedirectUriFromResponse(
        ResponseInterface $response,
        UriInterface $lastRequestUri
    ): ?UriInterface {
        /* @var WebPage $webPage */
        try {
            $webPage = Webpage::createFromResponse($lastRequestUri, $response);
        } catch (\Exception $exception) {
            return null;
        }

        $redirectUrl = null;
        $selector = 'meta[http-equiv=refresh]';

        /** @noinspection PhpUnhandledExceptionInspection */
        $inspector = new WebPageInspector($webPage);

        /* @var \DOMElement[] $metaRefreshElements */
        $metaRefreshElements = $inspector->querySelectorAll($selector);

        foreach ($metaRefreshElements as $metaRefreshElement) {
            if ($metaRefreshElement->hasAttribute('content')) {
                $contentAttribute = $metaRefreshElement->getAttribute('content');
                $urlMarkerPosition = stripos($contentAttribute, 'url=');

                if ($urlMarkerPosition !== false) {
                    $redirectUrl = substr($contentAttribute, $urlMarkerPosition + strlen('url='));
                }
            }
        }

        if (empty($redirectUrl)) {
            return null;
        }

        return AbsoluteUrlDeriver::derive($lastRequestUri, new Uri($redirectUrl));
    }
299583
function mv (sourceURI, destURI, callback) {
  if (!sourceURI) {
    callback(new Error('source URI is required'))
  }
  if (!destURI) {
    callback(new Error('dest URI is required'))
  }
  util.get(sourceURI, function (err, val, uri) {
    util.put(destURI, val, function (err, ret, uri) {
      if (!err) {
        util.rm(sourceURI, function(err, ret) {
          if (!err) {
            callback(null, ret, uri)
          } else {
            callback(err)
          }
        })
      } else {
        callback(err)
      }
    })
  })
}
684394
public function createAbsoluteUrl($uri)
    {
        if (!isset($uri)) {
            return null;
        }

        $uri = strval($uri);
        if ($this->isRelativeUri($uri)) {
            $parts = parse_url($uri);
            $path  = isset($parts['path']) ? $parts['path'] : '';
            $query = isset($parts['query']) ? $parts['query'] : '';
            $hash  = isset($parts['fragment']) ? $parts['fragment'] : '';

            return $this->baseUrl()->withPath($path)->withQuery($query)->withFragment($hash);
        }

        return $uri;
    }
220440
public function execute(string $uri, ContratoContaReceber $contratoContaReceber)
    {
        return $this->send(self::POST_METHOD, $uri, $contratoContaReceber->toArray());
    }
107825
public function trace(string $uri)
    {
        $request = $this->getRequest($uri)
            ->setMethod('TRACE');

        return $this->send($request);
    }
156126
public function handleUri($uri)
    {
        $uri = $this->resolveAlias($uri);

        // Check has .min
        // $uri = Uri::addBase($uri, 'path');

        if (static::isAbsoluteUrl($uri)) {
            return $uri;
        }

        $assetUri = $this->path;

        if (static::isAbsoluteUrl($assetUri)) {
            return rtrim($assetUri, '/') . '/' . ltrim($uri, '/');
        }

        $root = $this->addSysPath($assetUri);

        $this->normalizeUri($uri, $assetFile, $assetMinFile);

        // Use uncompressed file first
        if ($this->config->get('system.debug')) {
            if (is_file($root . '/' . $assetFile)) {
                return $this->addBase($assetFile, 'path');
            }

            if (is_file($root . '/' . $assetMinFile)) {
                return $this->addBase($assetMinFile, 'path');
            }
        } else {
            // Use min file first
            if (is_file($root . '/' . $assetMinFile)) {
                return $this->addBase($assetMinFile, 'path');
            }

            if (is_file($root . '/' . $assetFile)) {
                return $this->addBase($assetFile, 'path');
            }
        }

        // All file not found, fallback to default uri.
        return $this->addBase($uri, 'path');
    }
1017389
public function withUri(UriInterface $uri, $preserveHost = false)
    {
        $request = $this->copy();
        $request->uri = $uri;
        
        if (!$preserveHost) {
            $request = $request->withHeader('Host', $request->uri->getHost());
        }
        
        return $request;
    }
1309412
public function resolve(UriInterface $uri, UriInterface $baseUri)
    {
        $baseUriReflector = new ReflectionObject($baseUri);
        if (!$baseUriReflector->hasMethod('resolve')) {
            $baseUri = new Uri($baseUri->toString());
            if ($uri instanceof Uri) {
                $uri = clone $uri;
            } else {
                $uri = new Uri($uri->toString());
            }
        } elseif (!$uri instanceof $baseUri) {
            $uri = $baseUriReflector->newInstance($uri->toString());
        } else {
            $uri = clone $uri;
        }

        return $uri->resolve($baseUri);
    }