Returns a string with the endpoint for the given command.

@param string $method Method for this command.

@return string
436416
protected function getEndpoint($method)
    {
        $endpoint = "me/email_verify";
        $nonce = $this->getArgument("nonce");
        if (!is_null($nonce)) {
            $endpoint .= "/$nonce";
            $this->delArgument("nonce");
        }
        return $endpoint;
    }
736470
private function getURL($endpoint = null)
    {
        if (is_null($endpoint)) {
            $endpoint = $this->getEndpoint();
        } else {
            $endpoint = '/api/' . $endpoint;
        }

        return $this->config['url'] . $endpoint;
    }
874807
protected function getEndpoint($method)
    {
        $endpoint = "tariffs";
        $countryIso = $this->getArgument("id");
        if (!is_null($countryIso)) {
            $endpoint .= "/$countryIso";
            $this->delArgument("id");
        }
        return $endpoint;
    }
510864
public function getUriRouteFor(string $method): ?Route
    {
        if (!$this->isMethodAllowed($method)) {
            return null;
        }

        return $this->uriRoutes[$method];
    }
1257993
protected function getPrefixName($method)
    {
        $prefix = $this->route->getCurrentRoute()->getPrefix();
        $prefix = str_replace('/', '.', $prefix);
        $prefix = preg_replace('/\b\.' . $method . '\b/', '', $prefix);
        $prefix = preg_replace('/\b' . $method . '\.\b/', '', $prefix);

        return $prefix;
    }
400324
public function send(string $method, string $endpoint, array $parameters = null)
    {
        /** @var string|array $parameters */
        $data = $this->processor->prepare($method, $parameters);

        switch ($method) {
            case 'get':
                return $this->adapter->get(
                    $this->getEndpoint() . '/' . trim($endpoint, '/') . trim($data, '/')
                );
            case 'post':
                return $this->adapter->post(
                    $this->getEndpoint() . '/' . trim($endpoint, '/'),
                    $data ?? []
                );
        }
    }
686248
protected function getJoinpointInvocationBody(ReflectionMethod $method): string
    {
        $isStatic = $method->isStatic();
        $scope    = $isStatic ? 'static::class' : '$this';
        $prefix   = $isStatic ? AspectContainer::STATIC_METHOD_PREFIX : AspectContainer::METHOD_PREFIX;

        $argumentList = new FunctionCallArgumentListGenerator($method);
        $argumentCode = $argumentList->generate();
        $return = 'return ';
        if ($method->hasReturnType()) {
            $returnType = (string) $method->getReturnType();
            if ($returnType === 'void') {
                // void return types should not return anything
                $return = '';
            }
        }

        if (!empty($argumentCode)) {
            $scope = "$scope, $argumentCode";
        }

        $body = "{$return}self::\$__joinPoints['{$prefix}:{$method->name}']->__invoke($scope);";

        return $body;
    }
76912
private function getFallbackHandler(string $method)
    {
        if (empty($this->fallback)) {
            return null;
        }

        $fallback   = \fallback($this->fallback);
        $interfaces = class_implements(static::class);
        foreach ($interfaces as $interface) {
            if (is_subclass_of($fallback, $interface)) {
                return [$fallback, $method];
            }
        }

        App::warning(sprintf('The %s class does not implement the %s interface', get_parent_class($fallback), JsonHelper::encode($interfaces, JSON_UNESCAPED_UNICODE)));

        return null;
    }
658552
private function getMethodSignature($method)
    {
        $validMethod = isset($this->methods[$method])
            && is_array($this->methods[$method])
            && count($this->methods[$method]) >= 2;

        if ($validMethod) {
            return $this->methods[$method];
        }

        return null;
    }
1122695
private function fixMethodCase(string $method) : string
    {
        $upperMethod = strtoupper($method);
        $isStandard = in_array($upperMethod, self::$standardMethods, true);

        return $isStandard ? $upperMethod : $method;
    }
1347056
protected function getEndpoint($method)
    {
        $endpoint = "sms";
        $searchParams = $this->getArgument("search_params");
        if (!is_null($searchParams)) {
            $queryString = http_build_query($searchParams);
            $this->delArgument("search_params");
            return "$endpoint?$queryString";
        }
        $operationId = $this->getArgument("id");
        if (!is_null($operationId)) {
            $endpoint .= "/$operationId";
            $this->delArgument("id");
        }
        return $endpoint;
    }
1355761
public function getMethod ($method)
	{
		
		// Get methods
		
		$this->getMethods ();
		
		// Loop through the methods
		
		foreach ($this->methods as $obj)
		{
			
			// If the method names match return 
			
			if (strtolower ($obj->get ('name')) == strtolower ($method))
			{
				return $obj;
			}
			
		}
		
		// Return FALSE
		
		return FALSE;
		
	}
1234500
protected function getClassFromMethod($method)
    {
        // Look for a studly class
        $class = Str::singular(Str::studly($method));

        foreach ($this->repositories as $repository) {
            if (class_exists($repository.$class)) {
                return $repository.$class;
            }
        }

        // Resume normal functioning
        return parent::getClassFromMethod($method);
    }
1351535
protected function filterMethod($method): ?string
    {
        if ($method === null) {
            return $method;
        }

        if (!\is_string($method)) {
            throw new \InvalidArgumentException(sprintf(
                'Unsupported HTTP method; must be a string, received %s',
                (\is_object($method) ? \get_class($method) : \gettype($method))
            ));
        }

        $method = \strtoupper($method);
        if (!isset($this->validMethods[$method])) {
            throw new \InvalidArgumentException($this, $method);
        }

        return $method;
    }
88997
public function get($method, $data = array())
    {
        //set cURL transfer option for get request
        // and get ouput
        return $this->createEndPoint($method, $data)
                    ->setOpt(CURLOPT_CUSTOMREQUEST, 'GET')
                    ->setopt(CURLOPT_HTTPGET, true)
                    ->exec();
    }
946187
protected function getAcceptContentType($method)
    {
        // Just to make PHPMD happy.
        $method = null;
        $acceptFile = $this->getArgument("accept_file");
        if (!is_null($acceptFile)) {
            return "text/csv";
        }
        $acceptAnyFile = $this->getArgument("accept_any_file");
        if (!is_null($acceptAnyFile)) {
            return "*/*";
        }
        $acceptSoundFile = $this->getArgument("accept_sound_file");
        if (!is_null($acceptSoundFile)) {
            return "audio/mpeg";
        }
        return 'application/json';
    }
309537
private function methodAllowsQueryString(string $method): bool
    {
        return (Http::GET === $method || Http::HEAD === $method);
    }