_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q255300 | StorageServiceSettings.createFromConnectionStringForTokenCredential | test | public static function createFromConnectionStringForTokenCredential($connectionString)
{
// Explicit case for AAD token, Connection string could only have account
// name.
$tokenizedSettings = self::parseAndValidateKeys($connectionString);
$scheme = Utilities::tryGetValueInsensitive(
Resources::DEFAULT_ENDPOINTS_PROTOCOL_NAME,
$tokenizedSettings
);
$accountName = Utilities::tryGetValueInsensitive(
Resources::ACCOUNT_NAME_NAME,
$tokenizedSettings
);
$endpointSuffix = Utilities::tryGetValueInsensitive(
Resources::ENDPOINT_SUFFIX_NAME,
$tokenizedSettings
);
return self::createStorageServiceSettings(
$tokenizedSettings,
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::BLOB_DNS_PREFIX,
$endpointSuffix
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::QUEUE_DNS_PREFIX,
$endpointSuffix
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::TABLE_DNS_PREFIX,
$endpointSuffix
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::FILE_DNS_PREFIX,
$endpointSuffix
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::BLOB_DNS_PREFIX,
$endpointSuffix,
true
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::QUEUE_DNS_PREFIX,
$endpointSuffix,
true
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::TABLE_DNS_PREFIX,
$endpointSuffix,
true
),
self::getServiceEndpoint(
$scheme,
$accountName,
Resources::FILE_DNS_PREFIX,
$endpointSuffix,
true
)
);
} | php | {
"resource": ""
} |
q255301 | MimeReaderWriter.encodeMimeMultipart | test | public function encodeMimeMultipart(array $bodyPartContents)
{
$count = count($bodyPartContents);
$mimeType = Resources::MULTIPART_MIXED_TYPE;
$batchGuid = Utilities::getGuid();
$batchId = sprintf('batch_%s', $batchGuid);
$contentType1 = array('content_type' => "$mimeType");
$changeSetGuid = Utilities::getGuid();
$changeSetId = sprintf('changeset_%s', $changeSetGuid);
$contentType2 = array('content_type' => "$mimeType; boundary=$changeSetId");
$options = array(
'encoding' => 'binary',
'content_type' => Resources::HTTP_TYPE
);
$eof = "\r\n";
$result = array();
$result['body'] = Resources::EMPTY_STRING;
$result['headers'] = array();
$batchBody =& $result['body'];
$batchHeaders =& $result['headers'];
$batchHeaders['Content-Type'] = $mimeType . "; $eof boundary=\"$batchId\"";
$batchBody .= "--" . $batchId . $eof;
$batchBody .= "Content-Type: $mimeType; boundary=\"$changeSetId\"" . $eof;
$batchBody .= $eof;
for ($i = 0; $i < count($bodyPartContents); $i++) {
$batchBody .= "--" . $changeSetId . $eof;
$batchBody .= "Content-Transfer-Encoding: binary" . $eof;
$batchBody .= "Content-Type: " . Resources::HTTP_TYPE . $eof;
$batchBody .= $eof . $bodyPartContents[$i] . $eof;
}
$batchBody .= "--" . $changeSetId . "--" . $eof;
$batchBody .= $eof;
$batchBody .= "--" . $batchId . "--" . $eof;
return $result;
} | php | {
"resource": ""
} |
q255302 | MimeReaderWriter.decodeMimeMultipart | test | public function decodeMimeMultipart($mimeBody)
{
// Find boundary
$boundaryRegex = '~boundary=(changesetresponse_.*)~';
preg_match($boundaryRegex, $mimeBody, $matches);
$boundary = trim($matches[1]);
// Split the requests
$requests = explode('--' . $boundary, $mimeBody);
// Get the body of each request
$result = array();
// The first and last element are not request
for ($i = 1; $i < count($requests) - 1; $i++) {
// Split the request header and body
preg_match("/^.*?\r?\n\r?\n(.*)/s", $requests[$i], $matches);
$result[] = $matches[1];
}
return $result;
} | php | {
"resource": ""
} |
q255303 | ListSharesResult.create | test | public static function create(array $parsedResponse, $location = '')
{
$result = new ListSharesResult();
$serviceEndpoint = Utilities::tryGetKeysChainValue(
$parsedResponse,
Resources::XTAG_ATTRIBUTES,
Resources::XTAG_SERVICE_ENDPOINT
);
$result->setAccountName(Utilities::tryParseAccountNameFromUrl(
$serviceEndpoint
));
$result->setPrefix(Utilities::tryGetValue(
$parsedResponse,
Resources::QP_PREFIX
));
$result->setMarker(Utilities::tryGetValue(
$parsedResponse,
Resources::QP_MARKER
));
$nextMarker = Utilities::tryGetValue(
$parsedResponse,
Resources::QP_NEXT_MARKER
);
if ($nextMarker != null) {
$result->setContinuationToken(
new MarkerContinuationToken(
$nextMarker,
$location
)
);
}
$result->setMaxResults(Utilities::tryGetValue(
$parsedResponse,
Resources::QP_MAX_RESULTS
));
$shares = array();
$shareArrays = array();
if (!empty($parsedResponse[Resources::QP_SHARES])) {
$array = $parsedResponse[Resources::QP_SHARES][Resources::QP_SHARE];
$shareArrays = Utilities::getArray($array);
}
foreach ($shareArrays as $shareArray) {
$shares[] = Share::create($shareArray);
}
$result->setShares($shares);
return $result;
} | php | {
"resource": ""
} |
q255304 | ListSharesResult.setShares | test | protected function setShares(array $shares)
{
$this->shares = array();
foreach ($shares as $share) {
$this->shares[] = clone $share;
}
} | php | {
"resource": ""
} |
q255305 | RetryMiddleware.retry | test | private function retry(
RequestInterface $request,
array $options,
ResponseInterface $response = null
) {
$options['delay'] = call_user_func(
$this->intervalCalculator,
++$options['retries']
);
//Change the request URI according to the location mode.
if (array_key_exists(Resources::ROS_LOCATION_MODE, $options)) {
$locationMode = $options[Resources::ROS_LOCATION_MODE];
//If have RA-GRS enabled for the request, switch between
//primary and secondary.
if ($locationMode == LocationMode::PRIMARY_THEN_SECONDARY ||
$locationMode == LocationMode::SECONDARY_THEN_PRIMARY) {
$primaryUri = $options[Resources::ROS_PRIMARY_URI];
$secondaryUri = $options[Resources::ROS_SECONDARY_URI];
$target = $request->getRequestTarget();
if (Utilities::startsWith($target, '/')) {
$target = substr($target, 1);
$primaryUri = new Uri($primaryUri . $target);
$secondaryUri = new Uri($secondaryUri . $target);
}
//substitute the uri.
if ((string)$request->getUri() == (string)$primaryUri) {
$request = $request->withUri($secondaryUri);
} elseif ((string)$request->getUri() == (string)$secondaryUri) {
$request = $request->withUri($primaryUri);
}
}
}
$handler = $options[Resources::ROS_HANDLER];
return \call_user_func($handler, $request, $options);
} | php | {
"resource": ""
} |
q255306 | Filter.applyAnd | test | public static function applyAnd(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'and', $right);
return $filter;
} | php | {
"resource": ""
} |
q255307 | Filter.applyOr | test | public static function applyOr(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'or', $right);
return $filter;
} | php | {
"resource": ""
} |
q255308 | Filter.applyEq | test | public static function applyEq(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'eq', $right);
return $filter;
} | php | {
"resource": ""
} |
q255309 | Filter.applyNe | test | public static function applyNe(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'ne', $right);
return $filter;
} | php | {
"resource": ""
} |
q255310 | Filter.applyGe | test | public static function applyGe(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'ge', $right);
return $filter;
} | php | {
"resource": ""
} |
q255311 | Filter.applyGt | test | public static function applyGt(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'gt', $right);
return $filter;
} | php | {
"resource": ""
} |
q255312 | Filter.applyLt | test | public static function applyLt(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'lt', $right);
return $filter;
} | php | {
"resource": ""
} |
q255313 | Filter.applyLe | test | public static function applyLe(Filter $left, Filter $right)
{
$filter = new BinaryFilter($left, 'le', $right);
return $filter;
} | php | {
"resource": ""
} |
q255314 | ContinuationToken.setLocation | test | public function setLocation($location)
{
Validate::canCastAsString($location, 'location');
Validate::isTrue(
$location == LocationMode::PRIMARY_ONLY ||
$location == LocationMode::SECONDARY_ONLY ||
$location == '',
sprintf(
Resources::INVALID_VALUE_MSG,
'location',
LocationMode::PRIMARY_ONLY . ' or ' . LocationMode::SECONDARY_ONLY
)
);
$this->location = $location;
} | php | {
"resource": ""
} |
q255315 | JsonSerializer.unserialize | test | public function unserialize($serialized)
{
Validate::canCastAsString($serialized, 'serialized');
$json = json_decode($serialized);
if ($json && !is_array($json)) {
return get_object_vars($json);
} else {
return $json;
}
} | php | {
"resource": ""
} |
q255316 | PeekMessagesResult.create | test | public static function create($parsedResponse)
{
$result = new PeekMessagesResult();
$queueMessages = array();
if (!empty($parsedResponse)) {
$rawMessages = Utilities::getArray(
$parsedResponse[Resources::QP_QUEUE_MESSAGE]
);
foreach ($rawMessages as $value) {
$message = QueueMessage::createFromPeekMessages($value);
$queueMessages[] = $message;
}
}
$result->setQueueMessages($queueMessages);
return $result;
} | php | {
"resource": ""
} |
q255317 | GetEntityResult.create | test | public static function create($body, IODataReaderWriter $serializer)
{
$result = new GetEntityResult();
$result->setEntity($serializer->parseEntity($body));
return $result;
} | php | {
"resource": ""
} |
q255318 | TableRestProxy.createOperationsContexts | test | private function createOperationsContexts(array $operations)
{
$contexts = array();
foreach ($operations as $operation) {
$context = null;
$type = $operation->getType();
switch ($type) {
case BatchOperationType::INSERT_ENTITY_OPERATION:
case BatchOperationType::UPDATE_ENTITY_OPERATION:
case BatchOperationType::MERGE_ENTITY_OPERATION:
case BatchOperationType::INSERT_REPLACE_ENTITY_OPERATION:
case BatchOperationType::INSERT_MERGE_ENTITY_OPERATION:
$table = $operation->getParameter(
BatchOperationParameterName::BP_TABLE
);
$entity = $operation->getParameter(
BatchOperationParameterName::BP_ENTITY
);
$context = $this->getOperationContext($table, $entity, $type);
break;
case BatchOperationType::DELETE_ENTITY_OPERATION:
$table = $operation->getParameter(
BatchOperationParameterName::BP_TABLE
);
$partitionKey = $operation->getParameter(
BatchOperationParameterName::BP_PARTITION_KEY
);
$rowKey = $operation->getParameter(
BatchOperationParameterName::BP_ROW_KEY
);
$etag = $operation->getParameter(
BatchOperationParameterName::BP_ETAG
);
$options = new DeleteEntityOptions();
$options->setETag($etag);
$context = $this->constructDeleteEntityContext(
$table,
$partitionKey,
$rowKey,
$options
);
break;
default:
throw new \InvalidArgumentException();
}
$contexts[] = $context;
}
return $contexts;
} | php | {
"resource": ""
} |
q255319 | TableRestProxy.getOperationContext | test | private function getOperationContext($table, Entity $entity, $type)
{
switch ($type) {
case BatchOperationType::INSERT_ENTITY_OPERATION:
return $this->constructInsertEntityContext($table, $entity, null);
case BatchOperationType::UPDATE_ENTITY_OPERATION:
return $this->constructPutOrMergeEntityContext(
$table,
$entity,
Resources::HTTP_PUT,
true,
null
);
case BatchOperationType::MERGE_ENTITY_OPERATION:
return $this->constructPutOrMergeEntityContext(
$table,
$entity,
Resources::HTTP_MERGE,
true,
null
);
case BatchOperationType::INSERT_REPLACE_ENTITY_OPERATION:
return $this->constructPutOrMergeEntityContext(
$table,
$entity,
Resources::HTTP_PUT,
false,
null
);
case BatchOperationType::INSERT_MERGE_ENTITY_OPERATION:
return $this->constructPutOrMergeEntityContext(
$table,
$entity,
Resources::HTTP_MERGE,
false,
null
);
default:
throw new \InvalidArgumentException();
}
} | php | {
"resource": ""
} |
q255320 | TableRestProxy.createBatchRequestBody | test | private function createBatchRequestBody(array $operations, array $contexts)
{
$mimeBodyParts = array();
$contentId = 1;
$count = count($operations);
Validate::isTrue(
count($operations) == count($contexts),
Resources::INVALID_OC_COUNT_MSG
);
for ($i = 0; $i < $count; $i++) {
$operation = $operations[$i];
$context = $contexts[$i];
$type = $operation->getType();
switch ($type) {
case BatchOperationType::INSERT_ENTITY_OPERATION:
case BatchOperationType::UPDATE_ENTITY_OPERATION:
case BatchOperationType::MERGE_ENTITY_OPERATION:
case BatchOperationType::INSERT_REPLACE_ENTITY_OPERATION:
case BatchOperationType::INSERT_MERGE_ENTITY_OPERATION:
$contentType = $context->getHeader(Resources::CONTENT_TYPE);
$body = $context->getBody();
$contentType .= ';type=entry';
$context->addOptionalHeader(Resources::CONTENT_TYPE, $contentType);
// Use mb_strlen instead of strlen to get the length of the string
// in bytes instead of the length in chars.
$context->addOptionalHeader(
Resources::CONTENT_LENGTH,
strlen($body)
);
break;
case BatchOperationType::DELETE_ENTITY_OPERATION:
break;
default:
throw new \InvalidArgumentException();
}
$context->addOptionalHeader(Resources::CONTENT_ID, $contentId);
$mimeBodyPart = $context->__toString();
$mimeBodyParts[] = $mimeBodyPart;
$contentId++;
}
return $this->mimeSerializer->encodeMimeMultipart($mimeBodyParts);
} | php | {
"resource": ""
} |
q255321 | TableRestProxy.constructDeleteEntityContext | test | private function constructDeleteEntityContext(
$table,
$partitionKey,
$rowKey,
DeleteEntityOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
Validate::isTrue(!is_null($partitionKey), Resources::NULL_TABLE_KEY_MSG);
Validate::isTrue(!is_null($rowKey), Resources::NULL_TABLE_KEY_MSG);
$method = Resources::HTTP_DELETE;
$headers = array();
$queryParams = array();
$statusCode = Resources::STATUS_NO_CONTENT;
$path = $this->getEntityPath($table, $partitionKey, $rowKey);
if (is_null($options)) {
$options = new DeleteEntityOptions();
}
$etagObj = $options->getETag();
$ETag = !is_null($etagObj);
$this->addOptionalHeader(
$headers,
Resources::IF_MATCH,
$ETag ? $etagObj : Resources::ASTERISK
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
Resources::JSON_CONTENT_TYPE
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
$context = new HttpCallContext();
$context->setHeaders($headers);
$context->setMethod($method);
$context->setPath($path);
$context->setQueryParameters($queryParams);
$context->addStatusCode($statusCode);
$context->setBody('');
$context->setServiceOptions($options);
return $context;
} | php | {
"resource": ""
} |
q255322 | TableRestProxy.constructPutOrMergeEntityContext | test | private function constructPutOrMergeEntityContext(
$table,
Entity $entity,
$verb,
$useETag,
TableServiceOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
Validate::notNullOrEmpty($entity, 'entity');
Validate::isTrue($entity->isValid($msg), $msg);
$method = $verb;
$headers = array();
$queryParams = array();
$statusCode = Resources::STATUS_NO_CONTENT;
$partitionKey = $entity->getPartitionKey();
$rowKey = $entity->getRowKey();
$path = $this->getEntityPath($table, $partitionKey, $rowKey);
$body = $this->odataSerializer->getEntity($entity);
if (is_null($options)) {
$options = new TableServiceOptions();
}
if ($useETag) {
$etag = $entity->getETag();
$ifMatchValue = is_null($etag) ? Resources::ASTERISK : $etag;
$this->addOptionalHeader($headers, Resources::IF_MATCH, $ifMatchValue);
}
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
Resources::JSON_FULL_METADATA_CONTENT_TYPE
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
$context = new HttpCallContext();
$context->setBody($body);
$context->setHeaders($headers);
$context->setMethod($method);
$context->setPath($path);
$context->setQueryParameters($queryParams);
$context->addStatusCode($statusCode);
$context->setServiceOptions($options);
return $context;
} | php | {
"resource": ""
} |
q255323 | TableRestProxy.constructInsertEntityContext | test | private function constructInsertEntityContext(
$table,
Entity $entity,
TableServiceCreateOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
Validate::notNullOrEmpty($entity, 'entity');
Validate::isTrue($entity->isValid($msg), $msg);
$method = Resources::HTTP_POST;
$context = new HttpCallContext();
$headers = array();
$queryParams = array();
$statusCode = Resources::STATUS_CREATED;
$path = $table;
$body = $this->odataSerializer->getEntity($entity);
if (is_null($options)) {
$options = new TableServiceCreateOptions();
}
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
$this->addOptionalHeader(
$headers,
Resources::PREFER,
$options->getDoesReturnContent() ? Resources::RETURN_CONTENT : null
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
$context->setBody($body);
$context->setHeaders($headers);
$context->setMethod($method);
$context->setPath($path);
$context->setQueryParameters($queryParams);
$context->addStatusCode($statusCode);
$context->setServiceOptions($options);
return $context;
} | php | {
"resource": ""
} |
q255324 | TableRestProxy.getEntityPath | test | private function getEntityPath($table, $partitionKey, $rowKey)
{
$encodedPK = $this->encodeODataUriValue($partitionKey);
$encodedRK = $this->encodeODataUriValue($rowKey);
return "$table(PartitionKey='$encodedPK',RowKey='$encodedRK')";
} | php | {
"resource": ""
} |
q255325 | TableRestProxy.putOrMergeEntityAsyncImpl | test | private function putOrMergeEntityAsyncImpl(
$table,
Entity $entity,
$verb,
$useETag,
TableServiceOptions $options = null
) {
$context = $this->constructPutOrMergeEntityContext(
$table,
$entity,
$verb,
$useETag,
$options
);
return $this->sendContextAsync($context)->then(function ($response) {
return UpdateEntityResult::create(
HttpFormatter::formatHeaders($response->getHeaders())
);
}, null);
} | php | {
"resource": ""
} |
q255326 | TableRestProxy.addOptionalQuery | test | private function addOptionalQuery(array $queryParam, Query $query)
{
if (!is_null($query)) {
$selectedFields = $query->getSelectFields();
if (!empty($selectedFields)) {
$final = $this->encodeODataUriValues($selectedFields);
$this->addOptionalQueryParam(
$queryParam,
Resources::QP_SELECT,
implode(',', $final)
);
}
if (!is_null($query->getTop())) {
$final = strval($this->encodeODataUriValue($query->getTop()));
$this->addOptionalQueryParam(
$queryParam,
Resources::QP_TOP,
$final
);
}
if (!is_null($query->getFilter())) {
$final = $this->buildFilterExpression($query->getFilter());
$this->addOptionalQueryParam(
$queryParam,
Resources::QP_FILTER,
$final
);
}
}
return $queryParam;
} | php | {
"resource": ""
} |
q255327 | TableRestProxy.encodeODataUriValues | test | private function encodeODataUriValues(array $values)
{
$list = array();
foreach ($values as $value) {
$list[] = $this->encodeODataUriValue($value);
}
return $list;
} | php | {
"resource": ""
} |
q255328 | TableRestProxy.queryTablesAsync | test | public function queryTablesAsync($options = null)
{
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$path = 'Tables';
if (is_null($options)) {
$options = new QueryTablesOptions();
} elseif (is_string($options)) {
$prefix = $options;
$options = new QueryTablesOptions();
$options->setPrefix($prefix);
} elseif ($options instanceof Filter) {
$filter = $options;
$options = new QueryTablesOptions();
$options->setFilter($filter);
}
$query = $options->getQuery();
$next = $options->getNextTableName();
$prefix = $options->getPrefix();
if (!empty($prefix)) {
// Append Max char to end '{' is 1 + 'z' in AsciiTable ==> upperBound
// is prefix + '{'
$prefixFilter = Filter::applyAnd(
Filter::applyGe(
Filter::applyPropertyName('TableName'),
Filter::applyConstant($prefix, EdmType::STRING)
),
Filter::applyLe(
Filter::applyPropertyName('TableName'),
Filter::applyConstant($prefix . '{', EdmType::STRING)
)
);
if (is_null($query)) {
$query = new Query();
}
if (is_null($query->getFilter())) {
// use the prefix filter if the query filter is null
$query->setFilter($prefixFilter);
} else {
// combine and use the prefix filter if the query filter exists
$combinedFilter = Filter::applyAnd(
$query->getFilter(),
$prefixFilter
);
$query->setFilter($combinedFilter);
}
}
$queryParams = $this->addOptionalQuery($queryParams, $query);
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_NEXT_TABLE_NAME,
$next
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
// One can specify the NextTableName option to get table entities starting
// from the specified name. However, there appears to be an issue in the
// Azure Table service where this does not engage on the server unless
// $filter appears in the URL. The current behavior is to just ignore the
// NextTableName options, which is not expected or easily detectable.
if (array_key_exists(Resources::QP_NEXT_TABLE_NAME, $queryParams)
&& !array_key_exists(Resources::QP_FILTER, $queryParams)
) {
$queryParams[Resources::QP_FILTER] = Resources::EMPTY_STRING;
}
$odataSerializer = $this->odataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($odataSerializer) {
$tables = $odataSerializer->parseTableEntries($response->getBody());
return QueryTablesResult::create(
HttpFormatter::formatHeaders($response->getHeaders()),
$tables
);
}, null);
} | php | {
"resource": ""
} |
q255329 | TableRestProxy.createTable | test | public function createTable($table, TableServiceCreateOptions $options = null)
{
return $this->createTableAsync($table, $options)->wait();
} | php | {
"resource": ""
} |
q255330 | TableRestProxy.createTableAsync | test | public function createTableAsync(
$table,
TableServiceCreateOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
$method = Resources::HTTP_POST;
$headers = array();
$postParams = array();
$queryParams = array();
$path = 'Tables';
$body = $this->odataSerializer->getTable($table);
if (is_null($options)) {
$options = new TableServiceCreateOptions();
}
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
$this->addOptionalHeader(
$headers,
Resources::PREFER,
$options->getDoesReturnContent() ? Resources::RETURN_CONTENT : null
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_CREATED,
$body,
$options
);
} | php | {
"resource": ""
} |
q255331 | TableRestProxy.getTable | test | public function getTable($table, GetTableOptions $options = null)
{
return $this->getTableAsync($table, $options)->wait();
} | php | {
"resource": ""
} |
q255332 | TableRestProxy.getTableAsync | test | public function getTableAsync(
$table,
GetTableOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$path = "Tables('$table')";
if (is_null($options)) {
$options = new GetTableOptions();
}
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
$odataSerializer = $this->odataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($odataSerializer) {
return GetTableResult::create($response->getBody(), $odataSerializer);
}, null);
} | php | {
"resource": ""
} |
q255333 | TableRestProxy.deleteTable | test | public function deleteTable($table, TableServiceOptions $options = null)
{
$this->deleteTableAsync($table, $options)->wait();
} | php | {
"resource": ""
} |
q255334 | TableRestProxy.deleteTableAsync | test | public function deleteTableAsync(
$table,
TableServiceOptions$options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
$method = Resources::HTTP_DELETE;
$headers = array();
$postParams = array();
$queryParams = array();
$path = "Tables('$table')";
if (is_null($options)) {
$options = new TableServiceOptions();
}
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_NO_CONTENT,
Resources::EMPTY_STRING,
$options
);
} | php | {
"resource": ""
} |
q255335 | TableRestProxy.queryEntitiesAsync | test | public function queryEntitiesAsync($table, $options = null)
{
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $table;
if (is_null($options)) {
$options = new QueryEntitiesOptions();
} elseif (is_string($options)) {
$queryString = $options;
$options = new QueryEntitiesOptions();
$options->setFilter(Filter::applyQueryString($queryString));
} elseif ($options instanceof Filter) {
$filter = $options;
$options = new QueryEntitiesOptions();
$options->setFilter($filter);
}
$queryParams = $this->addOptionalQuery($queryParams, $options->getQuery());
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_NEXT_PK,
$options->getNextPartitionKey()
);
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_NEXT_RK,
$options->getNextRowKey()
);
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
if (!is_null($options->getQuery())) {
$dsHeader = Resources::DATA_SERVICE_VERSION;
$maxdsValue = Resources::MAX_DATA_SERVICE_VERSION_VALUE;
$fields = $options->getQuery()->getSelectFields();
$hasSelect = !empty($fields);
if ($hasSelect) {
$this->addOptionalHeader($headers, $dsHeader, $maxdsValue);
}
}
$odataSerializer = $this->odataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($odataSerializer) {
$entities = $odataSerializer->parseEntities($response->getBody());
return QueryEntitiesResult::create(
HttpFormatter::formatHeaders($response->getHeaders()),
$entities
);
}, null);
} | php | {
"resource": ""
} |
q255336 | TableRestProxy.insertOrMergeEntity | test | public function insertOrMergeEntity(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->insertOrMergeEntityAsync($table, $entity, $options)->wait();
} | php | {
"resource": ""
} |
q255337 | TableRestProxy.insertOrMergeEntityAsync | test | public function insertOrMergeEntityAsync(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->putOrMergeEntityAsyncImpl(
$table,
$entity,
Resources::HTTP_MERGE,
false,
$options
);
} | php | {
"resource": ""
} |
q255338 | TableRestProxy.insertOrReplaceEntity | test | public function insertOrReplaceEntity(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->insertOrReplaceEntityAsync(
$table,
$entity,
$options
)->wait();
} | php | {
"resource": ""
} |
q255339 | TableRestProxy.insertOrReplaceEntityAsync | test | public function insertOrReplaceEntityAsync(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->putOrMergeEntityAsyncImpl(
$table,
$entity,
Resources::HTTP_PUT,
false,
$options
);
} | php | {
"resource": ""
} |
q255340 | TableRestProxy.updateEntity | test | public function updateEntity(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->updateEntityAsync($table, $entity, $options)->wait();
} | php | {
"resource": ""
} |
q255341 | TableRestProxy.updateEntityAsync | test | public function updateEntityAsync(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->putOrMergeEntityAsyncImpl(
$table,
$entity,
Resources::HTTP_PUT,
true,
$options
);
} | php | {
"resource": ""
} |
q255342 | TableRestProxy.mergeEntity | test | public function mergeEntity(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->mergeEntityAsync($table, $entity, $options)->wait();
} | php | {
"resource": ""
} |
q255343 | TableRestProxy.mergeEntityAsync | test | public function mergeEntityAsync(
$table,
Entity $entity,
TableServiceOptions $options = null
) {
return $this->putOrMergeEntityAsyncImpl(
$table,
$entity,
Resources::HTTP_MERGE,
true,
$options
);
} | php | {
"resource": ""
} |
q255344 | TableRestProxy.deleteEntity | test | public function deleteEntity(
$table,
$partitionKey,
$rowKey,
DeleteEntityOptions $options = null
) {
$this->deleteEntityAsync($table, $partitionKey, $rowKey, $options)->wait();
} | php | {
"resource": ""
} |
q255345 | TableRestProxy.deleteEntityAsync | test | public function deleteEntityAsync(
$table,
$partitionKey,
$rowKey,
DeleteEntityOptions $options = null
) {
$context = $this->constructDeleteEntityContext(
$table,
$partitionKey,
$rowKey,
$options
);
return $this->sendContextAsync($context);
} | php | {
"resource": ""
} |
q255346 | TableRestProxy.getEntity | test | public function getEntity(
$table,
$partitionKey,
$rowKey,
GetEntityOptions $options = null
) {
return $this->getEntityAsync(
$table,
$partitionKey,
$rowKey,
$options
)->wait();
} | php | {
"resource": ""
} |
q255347 | TableRestProxy.getEntityAsync | test | public function getEntityAsync(
$table,
$partitionKey,
$rowKey,
GetEntityOptions $options = null
) {
Validate::canCastAsString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
Validate::isTrue(!is_null($partitionKey), Resources::NULL_TABLE_KEY_MSG);
Validate::isTrue(!is_null($rowKey), Resources::NULL_TABLE_KEY_MSG);
$method = Resources::HTTP_GET;
$headers = array();
$queryParams = array();
$path = $this->getEntityPath($table, $partitionKey, $rowKey);
if (is_null($options)) {
$options = new GetEntityOptions();
}
// TODO: support payload format options
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::JSON_CONTENT_TYPE
);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
$options->getAccept()
);
$context = new HttpCallContext();
$context->setHeaders($headers);
$context->setMethod($method);
$context->setPath($path);
$context->setQueryParameters($queryParams);
$context->setStatusCodes(array(Resources::STATUS_OK));
$context->setServiceOptions($options);
$odataSerializer = $this->odataSerializer;
return $this->sendContextAsync($context)->then(
function ($response) use ($odataSerializer) {
return GetEntityResult::create(
$response->getBody(),
$odataSerializer
);
},
null
);
} | php | {
"resource": ""
} |
q255348 | TableRestProxy.batch | test | public function batch(
Models\BatchOperations $batchOperations,
Models\TableServiceOptions $options = null
) {
return $this->batchAsync($batchOperations, $options)->wait();
} | php | {
"resource": ""
} |
q255349 | TableRestProxy.batchAsync | test | public function batchAsync(
Models\BatchOperations $batchOperations,
Models\TableServiceOptions $options = null
) {
Validate::notNullOrEmpty($batchOperations, 'batchOperations');
$method = Resources::HTTP_POST;
$operations = $batchOperations->getOperations();
$contexts = $this->createOperationsContexts($operations);
$mime = $this->createBatchRequestBody($operations, $contexts);
$body = $mime['body'];
$headers = $mime['headers'];
$postParams = array();
$queryParams = array();
$path = '$batch';
if (is_null($options)) {
$options = new TableServiceOptions();
}
$odataSerializer = $this->odataSerializer;
$mimeSerializer = $this->mimeSerializer;
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
$this->addOptionalHeader(
$headers,
Resources::ACCEPT_HEADER,
Resources::JSON_FULL_METADATA_CONTENT_TYPE
);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_ACCEPTED,
$body,
$options
)->then(function ($response) use (
$operations,
$contexts,
$odataSerializer,
$mimeSerializer
) {
return BatchResult::create(
$response->getBody(),
$operations,
$contexts,
$odataSerializer,
$mimeSerializer
);
}, null);
} | php | {
"resource": ""
} |
q255350 | ListDirectoriesAndFilesResult.create | test | public static function create(array $parsedResponse, $location = '')
{
$result = new ListDirectoriesAndFilesResult();
$serviceEndpoint = Utilities::tryGetKeysChainValue(
$parsedResponse,
Resources::XTAG_ATTRIBUTES,
Resources::XTAG_SERVICE_ENDPOINT
);
$result->setAccountName(Utilities::tryParseAccountNameFromUrl(
$serviceEndpoint
));
$nextMarker = Utilities::tryGetValue(
$parsedResponse,
Resources::QP_NEXT_MARKER
);
if ($nextMarker != null) {
$result->setContinuationToken(
new MarkerContinuationToken(
$nextMarker,
$location
)
);
}
$result->setMaxResults(Utilities::tryGetValue(
$parsedResponse,
Resources::QP_MAX_RESULTS
));
$result->setMarker(Utilities::tryGetValue(
$parsedResponse,
Resources::QP_MARKER
));
$entries = Utilities::tryGetValue(
$parsedResponse,
Resources::QP_ENTRIES
);
if (empty($entries)) {
$result->setDirectories(array());
$result->setFiles(array());
} else {
$directoriesArray = Utilities::tryGetValue(
$entries,
Resources::QP_DIRECTORY
);
$filesArray = Utilities::tryGetValue(
$entries,
Resources::QP_FILE
);
$directories = array();
$files = array();
if ($directoriesArray != null) {
if (array_key_exists(Resources::QP_NAME, $directoriesArray)) {
$directoriesArray = [$directoriesArray];
}
foreach ($directoriesArray as $directoryArray) {
$directories[] = Directory::create($directoryArray);
}
}
if ($filesArray != null) {
if (array_key_exists(Resources::QP_NAME, $filesArray)) {
$filesArray = [$filesArray];
}
foreach ($filesArray as $fileArray) {
$files[] = File::create($fileArray);
}
}
$result->setDirectories($directories);
$result->setFiles($files);
}
return $result;
} | php | {
"resource": ""
} |
q255351 | ListDirectoriesAndFilesResult.setDirectories | test | protected function setDirectories(array $directories)
{
$this->directories = array();
foreach ($directories as $directory) {
$this->directories[] = clone $directory;
}
} | php | {
"resource": ""
} |
q255352 | ListDirectoriesAndFilesResult.setFiles | test | protected function setFiles(array $files)
{
$this->files = array();
foreach ($files as $file) {
$this->files[] = clone $file;
}
} | php | {
"resource": ""
} |
q255353 | Directory.create | test | public static function create(array $parsed)
{
$result = new Directory();
$name = Utilities::tryGetValue($parsed, Resources::QP_NAME);
$result->setName($name);
return $result;
} | php | {
"resource": ""
} |
q255354 | UpdateEntityResult.create | test | public static function create(array $headers)
{
$result = new UpdateEntityResult();
$result->setETag(
Utilities::tryGetValueInsensitive(Resources::ETAG, $headers)
);
return $result;
} | php | {
"resource": ""
} |
q255355 | HttpCallContext.setQueryParameters | test | public function setQueryParameters(array $queryParams)
{
$this->_queryParams = array();
foreach ($queryParams as $key => $value) {
$this->addQueryParameter($key, $value);
}
} | php | {
"resource": ""
} |
q255356 | HttpCallContext.setStatusCodes | test | public function setStatusCodes(array $statusCodes)
{
$this->_statusCodes = array();
foreach ($statusCodes as $value) {
$this->addStatusCode($value);
}
} | php | {
"resource": ""
} |
q255357 | HttpCallContext.removeHeader | test | public function removeHeader($name)
{
Validate::canCastAsString($name, 'name');
Validate::notNullOrEmpty($name, 'name');
unset($this->_headers[$name]);
} | php | {
"resource": ""
} |
q255358 | HistoryMiddleware.addHistory | test | public function addHistory(array $entry)
{
if ($this->path !== '') {
$this->appendNewEntryToPath($entry);
} else {
Validate::isTrue(
array_key_exists('request', $entry) &&
array_key_exists('options', $entry) &&
(array_key_exists('response', $entry) ||
array_key_exists('reason', $entry)),
'Given history entry not in correct format'
);
$this->history[] = $entry;
}
++$this->count;
} | php | {
"resource": ""
} |
q255359 | HistoryMiddleware.appendNewEntryToPath | test | private function appendNewEntryToPath(array $entry)
{
$entryNoString = "Entry " . $this->count;
$delimiter = str_pad(
$entryNoString,
self::TITLE_LENGTH,
'-',
STR_PAD_BOTH
) . PHP_EOL;
$entryString = $delimiter;
$entryString .= sprintf(
"Time: %s\n",
(new \DateTime("now", new \DateTimeZone('UTC')))->format('Y-m-d H:i:s')
);
$entryString .= MessageSerializer::objectSerialize($entry['request']);
if (array_key_exists('reason', $entry)) {
$entryString .= MessageSerializer::objectSerialize($entry['reason']);
} elseif (array_key_exists('response', $entry)) {
$entryString .= MessageSerializer::objectSerialize($entry['response']);
}
$entryString .= $delimiter;
Utilities::appendToFile($this->path, $entryString);
} | php | {
"resource": ""
} |
q255360 | QueryTablesResult.create | test | public static function create(array $headers, array $entries)
{
$result = new QueryTablesResult();
$headers = array_change_key_case($headers);
$result->setTables($entries);
$nextTableName = Utilities::tryGetValue(
$headers,
Resources::X_MS_CONTINUATION_NEXTTABLENAME
);
if ($nextTableName != null) {
$result->setContinuationToken(
new TableContinuationToken(
$nextTableName,
'',
'',
Utilities::getLocationFromHeaders($headers)
)
);
}
return $result;
} | php | {
"resource": ""
} |
q255361 | ListMessagesResult.create | test | public static function create(array $parsedResponse = null)
{
$result = new ListMessagesResult();
$queueMessages = array();
if (!empty($parsedResponse)) {
$rawMessages = Utilities::getArray($parsedResponse['QueueMessage']);
foreach ($rawMessages as $value) {
$message = QueueMessage::createFromListMessages($value);
$queueMessages[] = $message;
}
}
$result->setQueueMessages($queueMessages);
return $result;
} | php | {
"resource": ""
} |
q255362 | ListMessagesResult.setQueueMessages | test | protected function setQueueMessages(array $queueMessages)
{
$this->_queueMessages = array();
foreach ($queueMessages as $value) {
$this->_queueMessages[] = clone $value;
}
} | php | {
"resource": ""
} |
q255363 | CloudConfigurationManager._init | test | private static function _init()
{
if (!self::$_isInitialized) {
self::$_sources = array();
// Get list of default connection string sources.
$default = ConnectionStringSource::getDefaultSources();
foreach ($default as $name => $provider) {
self::$_sources[$name] = $provider;
}
self::$_isInitialized = true;
}
} | php | {
"resource": ""
} |
q255364 | Validate.isValidHostname | test | public static function isValidHostname($hostname)
{
if (defined('FILTER_VALIDATE_DOMAIN')) {
$isValid = filter_var($hostname, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME);
} else {
// (less accurate) fallback for PHP < 7.0
$isValid = preg_match('/^[a-z0-9_-]+(\.[a-z0-9_-]+)*$/i', $hostname);
}
if ($isValid) {
return true;
} else {
throw new \RuntimeException(
sprintf(Resources::INVALID_CONFIG_HOSTNAME, $hostname)
);
}
} | php | {
"resource": ""
} |
q255365 | Validate.isValidUri | test | public static function isValidUri($uri)
{
$isValid = filter_var($uri, FILTER_VALIDATE_URL);
if ($isValid) {
return true;
} else {
throw new \RuntimeException(
sprintf(Resources::INVALID_CONFIG_URI, $uri)
);
}
} | php | {
"resource": ""
} |
q255366 | Validate.methodExists | test | public static function methodExists($objectInstance, $method, $name)
{
Validate::canCastAsString($method, 'method');
Validate::notNull($objectInstance, 'objectInstance');
Validate::isObject($objectInstance, 'objectInstance');
if (method_exists($objectInstance, $method)) {
return true;
} else {
throw new \InvalidArgumentException(
sprintf(
Resources::ERROR_METHOD_NOT_FOUND,
$method,
$name
)
);
}
} | php | {
"resource": ""
} |
q255367 | Validate.isDateString | test | public static function isDateString($value, $name)
{
Validate::canCastAsString($value, 'value');
try {
new \DateTime($value);
return true;
} catch (\Exception $e) {
throw new \InvalidArgumentException(
sprintf(
Resources::ERROR_INVALID_DATE_STRING,
$name,
$value
)
);
}
} | php | {
"resource": ""
} |
q255368 | Validate.hasKey | test | public static function hasKey($key, $name, array $array)
{
Validate::isArray($array, $name);
if (!array_key_exists($key, $array)) {
throw new \UnexpectedValueException(
sprintf(
Resources::INVALID_VALUE_MSG,
$name,
sprintf(Resources::ERROR_KEY_NOT_EXIST, $key)
)
);
}
return true;
} | php | {
"resource": ""
} |
q255369 | Range.getRangeString | test | public function getRangeString()
{
$rangeString = '';
$rangeString .= ('bytes=' . $this->start . '-');
if ($this->end != null) {
$rangeString .= $this->end;
}
return $rangeString;
} | php | {
"resource": ""
} |
q255370 | QueueRestProxy.listQueuesAsync | test | public function listQueuesAsync(ListQueuesOptions $options = null)
{
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$path = Resources::EMPTY_STRING;
if (is_null($options)) {
$options = new ListQueuesOptions();
}
$maxResults = $options->getMaxResults();
$include = $options->getIncludeMetadata();
$include = $include ? 'metadata' : null;
$prefix = $options->getPrefix();
$marker = $options->getNextMarker();
$this->addOptionalQueryParam($queryParams, Resources::QP_COMP, 'list');
$this->addOptionalQueryParam($queryParams, Resources::QP_PREFIX, $prefix);
$this->addOptionalQueryParam($queryParams, Resources::QP_MARKER, $marker);
$this->addOptionalQueryParam($queryParams, Resources::QP_INCLUDE, $include);
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_MAX_RESULTS,
$maxResults
);
$dataSerializer = $this->dataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($dataSerializer) {
$parsed = $dataSerializer->unserialize($response->getBody());
return ListQueuesResult::create(
$parsed,
Utilities::getLocationFromHeaders($response->getHeaders())
);
}, null);
} | php | {
"resource": ""
} |
q255371 | QueueRestProxy.clearMessages | test | public function clearMessages($queueName, QueueServiceOptions $options = null)
{
$this->clearMessagesAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255372 | QueueRestProxy.createMessage | test | public function createMessage(
$queueName,
$messageText,
CreateMessageOptions $options = null
) {
return $this->createMessageAsync($queueName, $messageText, $options)->wait();
} | php | {
"resource": ""
} |
q255373 | QueueRestProxy.createMessageAsync | test | public function createMessageAsync(
$queueName,
$messageText,
CreateMessageOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
Validate::canCastAsString($messageText, 'messageText');
$method = Resources::HTTP_POST;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName . '/messages';
$body = Resources::EMPTY_STRING;
$message = new QueueMessage();
$message->setMessageText($messageText);
$body = $message->toXml($this->dataSerializer);
if (is_null($options)) {
$options = new CreateMessageOptions();
}
$this->addOptionalHeader(
$headers,
Resources::CONTENT_TYPE,
Resources::URL_ENCODED_CONTENT_TYPE
);
$visibility = $options->getVisibilityTimeoutInSeconds();
$timeToLive = $options->getTimeToLiveInSeconds();
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_VISIBILITY_TIMEOUT,
$visibility
);
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_MESSAGE_TTL,
$timeToLive
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
$dataSerializer = $this->dataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_CREATED,
$body,
$options
)->then(function ($response) use ($dataSerializer) {
$parsed = $dataSerializer->unserialize($response->getBody());
return CreateMessageResult::create($parsed);
}, null);
} | php | {
"resource": ""
} |
q255374 | QueueRestProxy.createQueue | test | public function createQueue(
$queueName,
Models\CreateQueueOptions $options = null
) {
$this->createQueueAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255375 | QueueRestProxy.createQueueAsync | test | public function createQueueAsync(
$queueName,
Models\CreateQueueOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
$method = Resources::HTTP_PUT;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName;
if (is_null($options)) {
$options = new CreateQueueOptions();
}
$metadata = $options->getMetadata();
$headers = $this->generateMetadataHeaders($metadata);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
array(Resources::STATUS_CREATED, Resources::STATUS_NO_CONTENT),
Resources::EMPTY_STRING,
$options
);
} | php | {
"resource": ""
} |
q255376 | QueueRestProxy.deleteMessage | test | public function deleteMessage(
$queueName,
$messageId,
$popReceipt,
QueueServiceOptions $options = null
) {
$this->deleteMessageAsync(
$queueName,
$messageId,
$popReceipt,
$options
)->wait();
} | php | {
"resource": ""
} |
q255377 | QueueRestProxy.deleteMessageAsync | test | public function deleteMessageAsync(
$queueName,
$messageId,
$popReceipt,
QueueServiceOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
Validate::canCastAsString($messageId, 'messageId');
Validate::notNullOrEmpty($messageId, 'messageId');
Validate::canCastAsString($popReceipt, 'popReceipt');
Validate::notNullOrEmpty($popReceipt, 'popReceipt');
$method = Resources::HTTP_DELETE;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName . '/messages/' . $messageId;
$body = Resources::EMPTY_STRING;
if (is_null($options)) {
$options = new QueueServiceOptions();
}
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_POPRECEIPT,
$popReceipt
);
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_NO_CONTENT,
$body,
$options
);
} | php | {
"resource": ""
} |
q255378 | QueueRestProxy.deleteQueue | test | public function deleteQueue($queueName, QueueServiceOptions $options = null)
{
$this->deleteQueueAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255379 | QueueRestProxy.deleteQueueAsync | test | public function deleteQueueAsync(
$queueName,
QueueServiceOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
$method = Resources::HTTP_DELETE;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName;
if (is_null($options)) {
$options = new QueueServiceOptions();
}
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_NO_CONTENT,
Resources::EMPTY_STRING,
$options
);
} | php | {
"resource": ""
} |
q255380 | QueueRestProxy.getQueueMetadata | test | public function getQueueMetadata($queueName, QueueServiceOptions $options = null)
{
return $this->getQueueMetadataAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255381 | QueueRestProxy.getQueueMetadataAsync | test | public function getQueueMetadataAsync(
$queueName,
QueueServiceOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName;
$body = Resources::EMPTY_STRING;
if (is_null($options)) {
$options = new QueueServiceOptions();
}
$this->addOptionalQueryParam($queryParams, Resources::QP_COMP, 'metadata');
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
$body,
$options
)->then(function ($response) {
$responseHeaders = HttpFormatter::formatHeaders($response->getHeaders());
$metadata = Utilities::getMetadataArray($responseHeaders);
$maxCount = intval(
Utilities::tryGetValue(
$responseHeaders,
Resources::X_MS_APPROXIMATE_MESSAGES_COUNT
)
);
return new GetQueueMetadataResult($maxCount, $metadata);
}, null);
} | php | {
"resource": ""
} |
q255382 | QueueRestProxy.listMessages | test | public function listMessages($queueName, ListMessagesOptions $options = null)
{
return $this->listMessagesAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255383 | QueueRestProxy.listMessagesAsync | test | public function listMessagesAsync(
$queueName,
ListMessagesOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
$method = Resources::HTTP_GET;
$headers = array();
$queryParams = array();
$postParams = array();
$path = $queueName . '/messages';
if (is_null($options)) {
$options = new ListMessagesOptions();
}
$messagesCount = $options->getNumberOfMessages();
$visibility = $options->getVisibilityTimeoutInSeconds();
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_NUM_OF_MESSAGES,
$messagesCount
);
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_VISIBILITY_TIMEOUT,
$visibility
);
$dataSerializer = $this->dataSerializer;
$options->setLocationMode(LocationMode::PRIMARY_ONLY);
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($dataSerializer) {
$parsed = $dataSerializer->unserialize($response->getBody());
return ListMessagesResult::create($parsed);
}, null);
} | php | {
"resource": ""
} |
q255384 | QueueRestProxy.peekMessages | test | public function peekMessages($queueName, PeekMessagesOptions $options = null)
{
return $this->peekMessagesAsync($queueName, $options)->wait();
} | php | {
"resource": ""
} |
q255385 | QueueRestProxy.peekMessagesAsync | test | public function peekMessagesAsync(
$queueName,
PeekMessagesOptions $options = null
) {
Validate::canCastAsString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
$method = Resources::HTTP_GET;
$headers = array();
$queryParams = array();
$postParams = array();
$path = $queueName . '/messages';
if (is_null($options)) {
$options = new PeekMessagesOptions();
}
$messagesCount = $options->getNumberOfMessages();
$this->addOptionalQueryParam($queryParams, Resources::QP_PEEK_ONLY, 'true');
$this->addOptionalQueryParam(
$queryParams,
Resources::QP_NUM_OF_MESSAGES,
$messagesCount
);
$dataSerializer = $this->dataSerializer;
return $this->sendAsync(
$method,
$headers,
$queryParams,
$postParams,
$path,
Resources::STATUS_OK,
Resources::EMPTY_STRING,
$options
)->then(function ($response) use ($dataSerializer) {
$parsed = $dataSerializer->unserialize($response->getBody());
return PeekMessagesResult::create($parsed);
}, null);
} | php | {
"resource": ""
} |
q255386 | SharedAccessSignatureHelper.generateAccountSharedAccessSignatureToken | test | public function generateAccountSharedAccessSignatureToken(
$signedVersion,
$signedPermissions,
$signedService,
$signedResourceType,
$signedExpiry,
$signedStart = "",
$signedIP = "",
$signedProtocol = ""
) {
// check that version is valid
Validate::canCastAsString($signedVersion, 'signedVersion');
Validate::notNullOrEmpty($signedVersion, 'signedVersion');
Validate::isDateString($signedVersion, 'signedVersion');
// validate and sanitize signed service
$signedService = $this->validateAndSanitizeSignedService($signedService);
// validate and sanitize signed resource type
$signedResourceType = $this->validateAndSanitizeSignedResourceType($signedResourceType);
// validate and sanitize signed permissions
$signedPermissions = $this->validateAndSanitizeSignedPermissions($signedPermissions);
// check that expiracy is valid
if ($signedExpiry instanceof \Datetime) {
$signedExpiry = Utilities::isoDate($signedExpiry);
}
Validate::canCastAsString($signedExpiry, 'signedExpiry');
Validate::notNullOrEmpty($signedExpiry, 'signedExpiry');
Validate::isDateString($signedExpiry, 'signedExpiry');
// check that signed start is valid
if ($signedStart instanceof \Datetime) {
$signedStart = Utilities::isoDate($signedStart);
}
Validate::canCastAsString($signedStart, 'signedStart');
if (strlen($signedStart) > 0) {
Validate::isDateString($signedStart, 'signedStart');
}
// check that signed IP is valid
Validate::canCastAsString($signedIP, 'signedIP');
// validate and sanitize signed protocol
$signedProtocol = $this->validateAndSanitizeSignedProtocol($signedProtocol);
// construct an array with the parameters to generate the shared access signature at the account level
$parameters = array();
$parameters[] = $this->accountName;
$parameters[] = $signedPermissions;
$parameters[] = $signedService;
$parameters[] = $signedResourceType;
$parameters[] = $signedStart;
$parameters[] = $signedExpiry;
$parameters[] = $signedIP;
$parameters[] = $signedProtocol;
$parameters[] = $signedVersion;
// implode the parameters into a string
$stringToSign = utf8_encode(implode("\n", $parameters) . "\n");
// decode the account key from base64
$decodedAccountKey = base64_decode($this->accountKey);
// create the signature with hmac sha256
$signature = hash_hmac("sha256", $stringToSign, $decodedAccountKey, true);
// encode the signature as base64 and url encode.
$sig = urlencode(base64_encode($signature));
//adding all the components for account SAS together.
$sas = 'sv=' . $signedVersion;
$sas .= '&ss=' . $signedService;
$sas .= '&srt=' . $signedResourceType;
$sas .= '&sp=' . $signedPermissions;
$sas .= '&se=' . $signedExpiry;
$sas .= $signedStart === ''? '' : '&st=' . $signedStart;
$sas .= $signedIP === ''? '' : '&sip=' . $signedIP;
$sas .= '&spr=' . $signedProtocol;
$sas .= '&sig=' . $sig;
// return the signature
return $sas;
} | php | {
"resource": ""
} |
q255387 | SharedAccessSignatureHelper.validateAndSanitizeSignedService | test | protected function validateAndSanitizeSignedService($signedService)
{
// validate signed service is not null or empty
Validate::canCastAsString($signedService, 'signedService');
Validate::notNullOrEmpty($signedService, 'signedService');
// The signed service should only be a combination of the letters b(lob) q(ueue) t(able) or f(ile)
$validServices = ['b', 'q', 't', 'f'];
return $this->validateAndSanitizeStringWithArray(
strtolower($signedService),
$validServices
);
} | php | {
"resource": ""
} |
q255388 | SharedAccessSignatureHelper.validateAndSanitizeSignedResourceType | test | protected function validateAndSanitizeSignedResourceType($signedResourceType)
{
// validate signed resource type is not null or empty
Validate::canCastAsString($signedResourceType, 'signedResourceType');
Validate::notNullOrEmpty($signedResourceType, 'signedResourceType');
// The signed resource type should only be a combination of the letters s(ervice) c(container) or o(bject)
$validResourceTypes = ['s', 'c', 'o'];
return $this->validateAndSanitizeStringWithArray(
strtolower($signedResourceType),
$validResourceTypes
);
} | php | {
"resource": ""
} |
q255389 | SharedAccessSignatureHelper.validateAndSanitizeSignedPermissions | test | protected function validateAndSanitizeSignedPermissions(
$signedPermissions
) {
// validate signed permissions are not null or empty
Validate::canCastAsString($signedPermissions, 'signedPermissions');
Validate::notNullOrEmpty($signedPermissions, 'signedPermissions');
$validPermissions = ['r', 'w', 'd', 'l', 'a', 'c', 'u', 'p'];
return $this->validateAndSanitizeStringWithArray(
strtolower($signedPermissions),
$validPermissions
);
} | php | {
"resource": ""
} |
q255390 | SharedAccessSignatureHelper.validateAndSanitizeSignedProtocol | test | protected function validateAndSanitizeSignedProtocol($signedProtocol)
{
Validate::canCastAsString($signedProtocol, 'signedProtocol');
// sanitize string
$sanitizedSignedProtocol = strtolower($signedProtocol);
if (strlen($sanitizedSignedProtocol) > 0) {
if (strcmp($sanitizedSignedProtocol, "https") != 0 && strcmp($sanitizedSignedProtocol, "https,http") != 0) {
throw new \InvalidArgumentException(Resources::SIGNED_PROTOCOL_INVALID_VALIDATION_MSG);
}
}
return $sanitizedSignedProtocol;
} | php | {
"resource": ""
} |
q255391 | SharedAccessSignatureHelper.validateAndSanitizeStringWithArray | test | protected function validateAndSanitizeStringWithArray($input, array $array)
{
$result = '';
foreach ($array as $value) {
if (strpos($input, $value) !== false) {
//append the valid permission to result.
$result .= $value;
//remove all the character that represents the permission.
$input = str_replace(
$value,
'',
$input
);
}
}
Validate::isTrue(
strlen($input) == '',
sprintf(
Resources::STRING_NOT_WITH_GIVEN_COMBINATION,
implode(', ', $array)
)
);
return $result;
} | php | {
"resource": ""
} |
q255392 | SharedAccessSignatureHelper.generateCanonicalResource | test | protected static function generateCanonicalResource(
$accountName,
$service,
$resource
) {
static $serviceMap = array(
Resources::RESOURCE_TYPE_BLOB => 'blob',
Resources::RESOURCE_TYPE_FILE => 'file',
Resources::RESOURCE_TYPE_QUEUE => 'queue',
Resources::RESOURCE_TYPE_TABLE => 'table',
);
$serviceName = $serviceMap[$service];
if (Utilities::startsWith($resource, '/')) {
$resource = substr($resource, 1);
}
return sprintf('/%s/%s/%s', $serviceName, $accountName, $resource);
} | php | {
"resource": ""
} |
q255393 | ServiceException.parseErrorMessage | test | protected static function parseErrorMessage(ResponseInterface $response)
{
//try to parse using xml serializer, if failed, return the whole body
//as the error message.
$serializer = new XmlSerializer();
$errorMessage = '';
try {
$internalErrors = libxml_use_internal_errors(true);
$parsedArray = $serializer->unserialize($response->getBody());
$messages = array();
foreach (libxml_get_errors() as $error) {
$messages[] = $error->message;
}
if (!empty($messages)) {
throw new \Exception(
sprintf(Resources::ERROR_CANNOT_PARSE_XML, implode('; ', $messages))
);
}
libxml_use_internal_errors($internalErrors);
if (array_key_exists(Resources::XTAG_MESSAGE, $parsedArray)) {
$errorMessage = $parsedArray[Resources::XTAG_MESSAGE];
} else {
$errorMessage = $response->getBody();
}
} catch (\Exception $e) {
$errorMessage = $response->getBody();
}
return $errorMessage;
} | php | {
"resource": ""
} |
q255394 | ServiceException.getRequestID | test | public function getRequestID()
{
$requestID = '';
if (array_key_exists(
Resources::X_MS_REQUEST_ID,
$this->getResponse()->getHeaders()
)) {
$requestID = $this->getResponse()
->getHeaders()[Resources::X_MS_REQUEST_ID][0];
}
return $requestID;
} | php | {
"resource": ""
} |
q255395 | ServiceException.getDate | test | public function getDate()
{
$date = '';
if (array_key_exists(
Resources::DATE,
$this->getResponse()->getHeaders()
)) {
$date = $this->getResponse()
->getHeaders()[Resources::DATE][0];
}
return $date;
} | php | {
"resource": ""
} |
q255396 | ServiceOptions.setMiddlewares | test | public function setMiddlewares(array $middlewares)
{
foreach ($middlewares as $middleware) {
self::validateIsMiddleware($middleware);
}
$this->middlewares = $middlewares;
} | php | {
"resource": ""
} |
q255397 | ServiceOptions.validateIsMiddleware | test | private static function validateIsMiddleware($middleware)
{
if (!(is_callable($middleware) || $middleware instanceof IMiddleware)) {
Validate::isTrue(
false,
Resources::INVALID_TYPE_MSG . 'callable or IMiddleware'
);
}
} | php | {
"resource": ""
} |
q255398 | ConnectionStringParser._parse | test | private function _parse()
{
$key = null;
$value = null;
$connectionStringValues = array();
while (true) {
$this->_skipWhiteSpaces();
if ($this->_pos == strlen($this->_value)
&& $this->_state != ConnectionStringParser::EXPECT_VALUE
) {
// Not stopping after the end has been reached and a value is
// expected results in creating an empty value, which we expect.
break;
}
switch ($this->_state) {
case ConnectionStringParser::EXPECT_KEY:
$key = $this->_extractKey();
$this->_state = ConnectionStringParser::EXPECT_ASSIGNMENT;
break;
case ConnectionStringParser::EXPECT_ASSIGNMENT:
$this->_skipOperator('=');
$this->_state = ConnectionStringParser::EXPECT_VALUE;
break;
case ConnectionStringParser::EXPECT_VALUE:
$value = $this->_extractValue();
$this->_state =
ConnectionStringParser::EXPECT_SEPARATOR;
$connectionStringValues[$key] = $value;
$key = null;
$value = null;
break;
default:
$this->_skipOperator(';');
$this->_state = ConnectionStringParser::EXPECT_KEY;
break;
}
}
// Must end parsing in the valid state (expected key or separator)
if ($this->_state == ConnectionStringParser::EXPECT_ASSIGNMENT) {
throw $this->_createException(
$this->_pos,
Resources::MISSING_CONNECTION_STRING_CHAR,
'='
);
}
return $connectionStringValues;
} | php | {
"resource": ""
} |
q255399 | ConnectionStringParser._createException | test | private function _createException($position, $errorString)
{
$arguments = func_get_args();
// Remove first and second arguments (position and error string)
unset($arguments[0], $arguments[1]);
// Create a short error message.
$errorString = vsprintf($errorString, $arguments);
// Add position.
$errorString = sprintf(
Resources::ERROR_PARSING_STRING,
$errorString,
$position
);
// Create final error message.
$errorString = sprintf(
Resources::INVALID_CONNECTION_STRING,
$this->_argumentName,
$errorString
);
return new \RuntimeException($errorString);
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.