Responsável por mandar Inclusão de Transferência de Caixa para Banco para Serviço da Rovereti
@param string $uri
@param TransferenciaCaixaBanco $transferenciaCaixaBanco
@return Response
188666
public function execute(string $uri, TransferenciaCaixaBanco $transferenciaCaixaBanco)
    {
        return $this->send(self::POST_METHOD, $uri, $transferenciaCaixaBanco->toArray());
    }
1368393
public function execute($uri)
    {
        foreach ($this->routes as $pattern => $callback) {
            if (preg_match($pattern, $uri, $params) === 1) {
                call_user_func_array($this->beforeRouteCallback, $params);
                array_shift($params);

                return call_user_func_array($callback, array_values($params));
            } else {
                error_log("$pattern did not match $uri");
            }
        }
    }
53665
public function request(
        OrderTransfer $orderTransfer,
        ComputopApiHeaderPaymentTransfer $computopApiHeaderPayment
    ): TransferInterface {
        $requestData = $this
            ->getMethodMapper($this->getPaymentMethodFromOrder($orderTransfer))
            ->buildRequest($orderTransfer, $computopApiHeaderPayment);

        return $this->sendRequest($requestData);
    }
1069341
public function setUri($uri=''){
    $this->uri = $uri;
    // 解析uri
    $uriObj = DdvUrl::parse($uri);
    empty($uriObj['host']) || $this->setHost($uriObj['host']);
    empty($uriObj['path']) || $this->setPath($uriObj['path']);
    empty($uriObj['query']) || $this->setQuery($uriObj['query']);
    empty($uriObj['port']) || $this->setPort($uriObj['port']);
    empty($uriObj['fragment']) || $this->setFragment($uriObj['fragment']);
    return $this;
  }
960057
public function request(
        QuoteTransfer $quoteTransfer,
        ComputopApiHeaderPaymentTransfer $computopApiHeaderPayment
    ): TransferInterface {
        $requestData = $this
            ->mapper
            ->buildRequest($quoteTransfer, $computopApiHeaderPayment);

        return $this->sendRequest($requestData);
    }
1074955
public static function secure( $uri = '', $params = array(), $retain = false ) 
	{
		return 'https://'.CCIn::host().static::to( $uri, $params, $retain );
	}
350990
public function redirect($uri, int $status = 301): ResponseInterface
    {
        if (!\is_string($uri) && !$uri instanceof UriInterface) {
            throw new \InvalidArgumentException('Uri MUST be a string or Psr\Http\Message\UriInterface instance; received "' .
                (\is_object($uri) ? \get_class($uri) : \gettype($uri)) . '"');
        }

        $this->header->set('Location', (string) $uri);

        return $this->empty($status);
    }
267404
public static function resolve( $uri ) 
	{	
		// cut unnecessary slashes and params
		if ( substr( $uri, -1 ) == '/' ) 
		{
			$uri = substr( $uri, 0, -1 );
		}
		
		if ( substr( $uri, 0, 1 ) == '/' ) 
		{
			$uri = substr( $uri, 1 );
		}
		
		$uri = CCStr::cut( $uri, '?' );
		
		// create new route instance
		$route = new CCRoute( $uri );
		
		// private route
		if ( substr( $uri, 0, 1 ) == '#' ) {
			if ( !array_key_exists( $uri, static::$privates ) ) 
			{
				throw new CCException( "CCRouter::resolve() - private route {$uri} could not be found." );
			}
			
			return static::configure( $route, static::$privates[$uri] );
		}
		
		// pass the route trough the priority events
		if ( $hook_route = CCEvent::pass( 'ccf.router.resolve.before', array( $route, false ) ) ) 
		{
			if ( $hook_route[1] === true ) 
			{
				return static::configure( $route, $hook_route[0] );
			}
		}
		
		// if the uri is empty root is requestet
		if ( empty( $uri ) ) 
		{
			// try one slash also aka empty
			if ( array_key_exists( '', static::$routes ) ) 
			{
				return static::configure( $route, static::$routes[''] );	
			}
			return static::configure( $route, static::$privates['#root'] );
		}
		
		// simple static key route
		if ( isset( static::$routes[$uri] ) ) 
		{
			return static::configure( $route, static::$routes[$uri] );
		}
		
		// explode the uri
		$uri_parts = explode( '/', $uri );
		
		// get the action
		$action = array_pop( $uri_parts );
			
		// implode the uri without action
		$uri_without_action = implode( '/', $uri_parts );
		
		// try the static key with an action
		if ( isset( $action ) ) 
		{
			if ( isset( static::$routes[$uri_without_action] ) ) 
			{
				if ( CCController::has_action( static::$routes[$uri_without_action], $action ) )
				{
					$route->action = $action;	
					return static::configure( $route, static::$routes[$uri_without_action] );
				}
			}
		}
		
		// dynamic keys
		foreach( static::$routes as $pattern => $dynamic_route ) 
		{	
			// try the dynamic route only if it can be a pattern
			if ( strpos( $pattern, '[' ) !== false && strpos( $pattern, ']' ) !== false ) 
			{
				// build an reqular expression	
				$regx = '#^'.CCStr::replace( $pattern, static::$filters ).'$#i';

				// try to match the uri with regex
				if ( preg_match( $regx, $uri, $params ) ) 
				{	
					// remove the first param
					unset( $params[0] );
					
					$route->action = null;
					$route->params = $params;
					
					return static::configure( $route, $dynamic_route );
				}
				
				// try to match the uri without the action with the regex
				if ( is_string($dynamic_route) && preg_match( $regx, $uri_without_action, $params ) ) 
				{
					if ( CCController::has_action( $dynamic_route, $action ) ) 
					{
						// remove the first param
						unset( $params[0] );
					
						$route->action = $action;
						$route->params = $params;
					
						return static::configure( $route, $dynamic_route );	
					}
				}
			}
		}      
		
		/*
		 * pass to events
		 */
		if ( $hook_route = CCEvent::pass( 'ccf.router.resolve.after', array( $route, false ) ) ) {
			if ( $hook_route[1] === true ) {
				return static::configure( $route, $hook_route[0] );
			}
		}
		
		return false;
	}
358673
public function redirecionar(
        Request $request,
        AtendimentoService $atendimentoService,
        TranslatorInterface $translator
    ) {
        $envelope = new Envelope();
        $data     = json_decode($request->getContent());

        $usuario     = $this->getUser();
        $unidade     = $usuario->getLotacao()->getUnidade();
        $servico     = (int) $data->servico;
        $novoUsuario = null;
        $atual       = $atendimentoService->atendimentoAndamento($usuario->getId(), $unidade);

        if (!$atual) {
            throw new Exception(
                $translator->trans('error.attendance.not_in_process', [], self::DOMAIN)
            );
        }
        
        if (isset($data->usuario)) {
            $novoUsuario = $this
                ->getDoctrine()
                ->getManager()
                ->getRepository(Usuario::class)
                ->find($data->usuario);
        }

        $redirecionado = $atendimentoService->redirecionar($atual, $unidade, $servico, $novoUsuario);
        if (!$redirecionado->getId()) {
            throw new Exception(
                $translator->trans(
                    'error.attendance.redirect',
                    [
                        '%atendimento%' => $atual->getId(),
                        '%servico%'     => $servico,
                    ],
                    self::DOMAIN
                )
            );
        }

        return $this->json($envelope);
    }
1301270
private function getNonce(string $uri): Promise {
        if (empty($this->nonces)) {
            return $this->requestNonce($uri);
        }

        return new Success(array_shift($this->nonces));
    }
755534
public function getRepositoryPermission($uri, $recipientUri)
    {
        $url = $this->service_url . '/permissions' . $uri;
        $url .= ";recipient=" . str_replace('/', '%2F', $recipientUri);
        $data = $this->service->prepAndSend($url, array(200), 'GET', null, true);
        return RepositoryPermission::createFromJSON($data);
    }
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);
    }
83044
public function codeCreateAskResourceOwnerForApprovalResponse(
        ClientInterface $client,
        string $redirectUri = null,
        bool $isScopeModified = false,
        array $scopeList = null,
        string $state = null,
        array $extraParameters = []
    ): ResponseInterface {
        $this->logDebug('Asking resource owner for scope approval (code grant).');
        return $this->getIntegration()->createAskResourceOwnerForApprovalResponse(
            ResponseTypes::AUTHORIZATION_CODE,
            $client,
            $redirectUri,
            $isScopeModified,
            $scopeList,
            $state,
            $extraParameters
        );
    }
515637
protected function getResponse($uri, array $queryParams = array())
    {
        $request = $this->httpClient->get($uri, array(), array('query' => $queryParams));

        return $request->send()->json();
    }
1328703
public function options(string $uri)
    {
        $request = $this->getRequest($uri)
            ->setMethod('OPTIONS');

        return $this->send($request);
    }
548079
public function get(string $uri): PromiseInterface
    {
        $request = new Request($uri);

        return $this->processRequest($request);
    }
551428
public function get(string $uri)
    {
        $request = $this->getRequest($uri);

        return $this->send($request);
    }