Get domain summary static info.

@param array $options Supported options:
{
config: the optional bce configuration, which will overwrite the
default client configuration that was passed in constructor.
}
@return mixed
@throws BceClientException
354399
public function getDomainSummaryStatistics($options = array())
    {
        list($config, $startTime, $endTime) = $this->parseOptions(
            $options,
            'config',
            'startTime',
            'endTime'
        );

        if (empty($startTime)) {
            throw new BceClientException("The query parameter startTime "
                . "should NOT be null or empty string");
        }
        if (empty($endTime)) {
            throw new BceClientException("The query parameter endTime "
                . "should NOT be null or empty string");
        }

        $params = array(
            'startTime' => $startTime,
            'endTime' => $endTime,
        );

        return $this->sendRequest(
            HttpMethod::GET,
            array(
                'config' => $config,
                'params' => $params,
            ),
            "/statistics/domain/summary"
        );
    }
1199204
public function getData($options)
    {
        $data = [];

        if (!empty($options)) {
            $ids = $this->getValue($this->keys['ids'], $options, null);
            $limit = $this->getValue($this->keys['limit'], $options, null);
            $headline = $this->getValue($this->keys['headline'], $options, null);

            // set headline
            if ($headline) {
                $data['headline'] = $headline;
            }

            if ($ids) {
                // Parse accounts
                $accountIds = explode(',', $ids);
                foreach ($accountIds as $index => $id) {
                    // check if limit is exceeded
                    if ($limit && $index >= $limit) {
                        $data['further'] = count($accountIds) - $limit;
                        break;
                    }

                    // fetch and parse account data
                    $account = $this->accountRepository->find($id);
                    if (!$account) {
                        throw new WidgetEntityNotFoundException(
                            'Entity \'Account\' with id ' . $id . ' not found!',
                            $this->widgetName,
                            $id
                        );
                    }
                    $data['accounts'][] = $this->parseAccount($account);
                }
            }

            // set emptylabel
            if (isset($this->keys['emptyLabel'])) {
                $data['emptyLabel'] = $this->keys['emptyLabel'];
            }

            return $data;
        }
    }
98773
private function getCollectionOptionsHash(array $options)
    {
        ksort($options);
        $str = '';
        foreach ($options as $option) {
            if (!$option instanceof  Serializable) {
                // All valid Collection options are BSON serializable
                continue;
            }
            $str .= serialize($option->bsonSerialize());
        }

        return md5($str);
    }
303550
private function getRequest($options)
    {
        $headers = isset($options['headers']) ? $options['headers'] : [];
        $headers['User-Agent'] = 'sanity-php ' . Version::VERSION;

        if (!empty($this->clientConfig['token'])) {
            $headers['Authorization'] = 'Bearer ' . $this->clientConfig['token'];
        }

        $method = isset($options['method']) ? $options['method'] : 'GET';
        $body = isset($options['body']) ? $options['body'] : null;
        $cdnAllowed = (
            isset($options['cdnAllowed']) &&
            $options['cdnAllowed'] &&
            $this->clientConfig['useCdn']
        );

        $baseUrl = $cdnAllowed
            ? $this->clientConfig['cdnUrl']
            : $this->clientConfig['url'];

        $url = $baseUrl . $options['url'];

        return new Request($method, $url, $headers, $body);
    }
345454
public function listBuckets($options = array())
    {
        list($config) = $this->parseOptions($options, BosOptions::CONFIG);

        return $this->sendRequest(
            HttpMethod::GET,
            array(
                BosOptions::CONFIG => $config
            )
        );
    }
1348865
public function bitcoincharts($options = []) {
		$options += $this->settings;
		$url = 'http://api.bitcoincharts.com/v1/markets.json';
		$res = $this->_getBitcoincharts($url);
		if (!$res) {
			return false;
		}
		$array = [];
		foreach ($res as $val) {
			$array[$val['currency']] = $val;
			unset($array[$val['currency']]['currency']);
		}

		if (empty($options['currency'])) {
			return $array;
		}
		if (empty($array[$options['currency']])) {
			return false;
		}
		return $array[$options['currency']];
	}
307028
public function getInfo($option)
    {
        if (array_key_exists($option, $this->infos)) {
            return $this->infos[$option];
        }

        throw new \DomainException("Option {$option} not found.");
    }
746822
public function config($options)
    {
        if (is_array($options))
        {
            $this->EightdownConfig = array_merge($this->EightdownConfig, $options);

            // Set generic parsedown config items.
            $this->setBreaksEnabled( !!$this->config('general.keepLineBreaks') )
                ->setMarkupEscaped( !$this->config('general.parseHTML') )
                ->setUrlsLinked( !!$this->config('general.parseURL') );

            // Disable items
            if (isset($options['disable']))
            {
                foreach ($options['disable'] as $disabledMarkup)
                {
                    $this->removeBlockByName($disabledMarkup);
                    $this->removeInlineByName($disabledMarkup);
                }
            }

            if (isset($options['enable']))
            {
                foreach ($options['enable'] as $enabledMarkup)
                {
                    $enableMarkupMethod = camel_case("enable_markup_{$enabledMarkup}");

                    if (is_callable([$this, $enableMarkupMethod]))
                    {
                        $this->{$enableMarkupMethod}();
                    }
                }
            }

            return $this;
        }
        else if (is_string($options))
        {
            return array_get($this->EightdownConfig, $options);
        }
    }
740605
protected function getAuthorizationParameters(array $options)
    {
        if (empty($options['state'])) {
            $options['state'] = $this->getRandomState();
        }

        if (empty($options['scope'])) {
            $options['scope'] = $this->getDefaultScopes();
        }

        $options += [
            'response_type'   => 'code',
            'approval_prompt' => 'auto'
        ];

        if (is_array($options['scope'])) {
            $separator = $this->getScopeSeparator();
            $options['scope'] = implode($separator, $options['scope']);
        }

        // Store the state as it may need to be accessed later on.
        $this->state = $options['state'];

        // Business code layer might set a different redirect_uri parameter
        // depending on the context, leave it as-is
        if (!isset($options['redirect_uri'])) {
            $options['redirect_uri'] = $this->redirectUri;
        }

        $options['client_id'] = $this->clientId;

        return $options;
    }
1050622
protected function getAuthorizationParameters(array $options)
    {
        $options = parent::getAuthorizationParameters($options);
        $options['purpose'] = $this->purpose;
        return $options;
    }
630791
public function basicGet($options)
    {
        $args = new Writer();
        $args->writeShort($options['ticket'])
            ->writeShortStr($options['queue'])
            ->writeBit($options['no_ack']);
        return $args;
    }
719172
public function listBuckets($options = NULL)
    {
        if ($this->hostType === self::OSS_HOST_TYPE_CNAME) {
            throw new OssException("operation is not permitted with CName host");
        }
        $this->precheckOptions($options);
        $options[self::OSS_BUCKET] = '';
        $options[self::OSS_METHOD] = self::OSS_HTTP_GET;
        $options[self::OSS_OBJECT] = '/';
        $response = $this->auth($options);
        $result = new ListBucketsResult($response);
        return $result->getData();
    }
285752
public function fetch($options = array()) {
        $options = new Values($options);

        $params = Values::of(array('UiVersion' => $options['uiVersion'], ));

        $payload = $this->version->fetch(
            'GET',
            $this->uri,
            $params
        );

        return new ConfigurationInstance($this->version, $payload);
    }
935273
private function getDefaultHttpClientOptions(array $options = []): array
    {
        $headers = [];

        if ($this->token !== null) {
            $headers['Authorization'] = 'Bearer '.$this->token;
        }

        $languagesInOptions = (array_key_exists('headers', $options) &&
            array_key_exists('Accept-Language', $options['headers']));
        if ($this->languages !== null && $languagesInOptions === false) {
            $headers['Accept-Language'] = join(', ', $this->languages);
        }

        if ($this->version !== null) {
            $headers['Accept'] = 'application/vnd.thetvdb.v'.$this->version;
        }

        $options['http_errors'] = false;

        return array_merge_recursive(['headers' => $headers], $options);
    }
717036
public static function GetConnection ($options) {
		$connection_name = static::AdjustConnectionName($options);

		if (!isset(static::$_connectionList[$connection_name])) {
			static::_Connect($options);
		}
		return static::$_connectionList[$connection_name];
	}
806053
public function getUsers($options = [])
    {
        $query_params = [];

        if (!empty($options['from_timestamp'])) {
            $query_params['from_ts'] = $options['from_timestamp'];
        }

        if (!empty($options['limit'])) {
            $query_params['limit'] = $options['limit'];
        }

        return $this->apiRequest([
            'method' => 'GET',
            'path' => '/users',
            'jwt' => $this->getServerToken()['token'],
            'query' => $query_params
        ]);
    }
682286
public function get(array $options)
    {
        $options = $this->options($options);

        $response = $this->client->request('GET', $this->api_host.$this->api_prefix, $options);
        $content = $response->getBody()->getContents();

        $content = $this->repair->repair($content);
        $content = $this->detector->detect($content);

        return $content;
    }