Get request

 @param [String] path
 @param [Hash,NilClass] params
 @param [Hash] headers
 @return [Hash]
767395
def get(path, params = nil, headers = {}, auth = true)
      request(path: path, query: params, headers: headers, auth: auth)
    end
137811
def page_request(path, params={})
      if params[PARAM_PER_PAGE] == NOT_FOUND
        params[PARAM_PER_PAGE] = default_page_size
      end
      if params[PARAM_PAGE] && params[PARAM_PAGE] == NOT_FOUND
        params[PARAM_PAGE] = default_page
      end

      current_api.get_request(path, ParamsHash.new(params))
    end
1150177
def get(path, options = {})
      if options[:query].nil?
        options.merge!({ query: { api_key: @key } })
      else
        options[:query].merge!({ api_key: @key })
      end

      response = self.class.get path, options
      raise LoLBaseError, response.message if response.code != 200
      response.body
    end
27226
public function get($path, $params = array(), $vars = array()) {
    $request = $this->request();
    $request = $this->prepareRequest($request);

    $response = $request->get($this->endpoint . $path, $params, $vars);
    return $this->handleResponse($response);
  }
1037483
def GET(self, path):
        
        url = self._absolute_url(path)
        resp = requests.get(url, headers=self.headers, verify=self.verify_ssl)
        if resp.status_code != 200:
            raise MispTransportError('GET %s: returned status=%d', path, resp.status_code)
        return resp.content
167860
public function get($path, $params = null){
        $url_params = '';
        if (is_array($params)){
            $url_params = '?' . http_build_query($params);
        }
        
        return $this->_call('GET', $path . $url_params);
    }
165037
def request(uri, method = :get, body = nil, query = nil, content_type = nil)
      headers = {}

      {
        'Content-Type'                  => content_type || 'application/json',
        'User-Agent'                    => "Parse for Ruby, #{VERSION}",
        Protocol::HEADER_MASTER_KEY     => @master_key,
        Protocol::HEADER_APP_ID         => @application_id,
        Protocol::HEADER_API_KEY        => @api_key,
        Protocol::HEADER_SESSION_TOKEN  => @session_token
      }.each do |key, value|
        headers[key] = value if value
      end

      uri = ::File.join(path, uri)
      response = @session.send(method, uri, query || body || {}, headers)
      response.body

    # NOTE: Don't leak our internal libraries to our clients.
    # Extend this list of exceptions as needed.
    rescue Faraday::Error::ClientError => e
      raise Parse::ConnectionError, e.message
    end
132708
def request(http_method, path, body = '', headers = {})
      puts "#{http_method}: #{path} - [#{body}]" if @http_debug
      @request_client.request(http_method, path, body, headers)
    end
65092
protected function pureGet(string $path, array $params = [], array $headers = [])
    {
        if ($this->perPage !== null && !isset($params['pagelen'])) {
            $params['pagelen'] = $this->perPage;
        }

        if ($params) {
            $path .= '?'.http_build_query($params);
        }

        return $this->client->get(self::computePath($path), $headers);
    }
829175
public function get($path, array $parameters = [], $headers = [])
    {
        $response = $this->getClient()->getHttpClient()->get($path, $parameters, $headers);

        return $this->decodeResponse($response);
    }
1199001
def get(path, options={}, raw=false, faraday_options={})
      request(:get, path, options, raw, faraday_options)
    end
47801
def get(path, query=nil, headers={})
      response = execute :get, path, query, headers
      hash = JSON.parse response.body
    end
507472
def list(path, params = {}, headers = {})
      params = params.merge(list: true)
      request(:get, path, params, headers)
    end
976092
def get(request_uri, params={})
      sp = signed_params("GET", request_uri, params)
      http_client.get(request_uri, sp)
    end
544116
def get(request_path, klass)
      response = session.send_request('GET', path + request_path)
      data = response.fetch(klass.tag)
      resource = klass.new(data.merge(parent: self))
      resource.assign_errors(response)
      resource
    end
44005
def get(self, path, params, **options):
        
        return self.request('get', path, params=params, **options)
1313406
def get!(path, extra=nil, params={})
      path, extra, params = normalize path, extra, params
      key = cache_key path, extra, params

      @last_payload = cache.get key do
        http_get(path, extra, params)
      end

      @last_url = @last_payload.request.last_uri.to_s
      @last_payload
    end