public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post")] ApplicationInfo info,
ILogger log)
{
var table = TableUtilities.GetCloudTable("Applications");
var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
var result = await table.ExecuteAsync(operation);
var application = result.Result as ApplicationEntity;
if (application == null)
{
return(new NotFoundResult());
}
if (application.Password.Equals(info.Password) == false)
{
return(new UnauthorizedResult());
}
operation = TableOperation.Delete(application);
await table.ExecuteAsync(operation);
return(new NoContentResult());
}
/// <summary>
/// Callback on DataContext object sending request.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
private void TableServiceContext_SendingRequest(object sender, SendingRequestEventArgs e)
{
HttpWebRequest request = e.Request as HttpWebRequest;
// Check timeout
int timeoutDex = request.RequestUri.Query.LastIndexOf("&timeout=", System.StringComparison.Ordinal);
if (timeoutDex > 0)
{
timeoutDex += 9; // Magic number -> length of "&timeout="
int endDex = request.RequestUri.Query.IndexOf('&', timeoutDex);
string timeoutString = endDex > 0
? request.RequestUri.Query.Substring(timeoutDex, endDex - timeoutDex)
: request.RequestUri.Query.Substring(timeoutDex);
int result = -1;
if (int.TryParse(timeoutString, out result) && result > 0)
{
request.Timeout = result * 1000; // Convert to ms
}
}
// Sign request
if (this.ServiceClient.Credentials.IsSharedKey)
{
this.AuthenticationHandler.SignRequest(request, null /* operationContext */);
}
else if (this.ServiceClient.Credentials.IsSAS)
{
Uri transformedUri = this.ServiceClient.Credentials.TransformUri(request.RequestUri);
// Recreate the request
HttpWebRequest newRequest = WebRequest.Create(transformedUri) as HttpWebRequest;
TableUtilities.CopyRequestData(newRequest, request);
e.Request = newRequest;
request = newRequest;
}
lock (this.cancellationLock)
{
if (this.cancellationRequested)
{
throw new OperationCanceledException(SR.OperationCanceled);
}
this.currentRequest = request;
}
// SAS will be handled directly by the queries themselves prior to transformation
request.Headers.Add(
Constants.HeaderConstants.StorageVersionHeader,
Constants.HeaderConstants.TargetStorageVersion);
CommonUtility.ApplyRequestOptimizations(request, -1);
if (this.sendingSignedRequestAction != null)
{
this.sendingSignedRequestAction(request);
}
}
public static void TestingTables1()
{
TableUtilities tableUtil = new TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
List<string> tables;
Console.WriteLine("List tables ");
if (tableUtil.ListTables(out tables))
{
Console.WriteLine("true");
if (tables != null)
{
foreach (string tableName in tables)
{
Console.Write(tableName + " ");
}
Console.WriteLine();
}
}
else
Console.WriteLine("false");
Separator();
Console.WriteLine("Create table ");
if (tableUtil.CreateTable("sampletable"))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
}
private ResultSegment <TElement> ParseTableQueryResponse(IEnumerable <TElement> dataServiceQueryResponse, RequestResult reqResult, TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > cmd)
{
if (reqResult.Exception != null)
{
DataServiceClientException dsce = TableUtilities.FindInnerExceptionOfType <DataServiceClientException>(reqResult.Exception);
if (this.IgnoreResourceNotFoundException && dsce != null && (HttpStatusCode)dsce.StatusCode == HttpStatusCode.NotFound)
{
return(new ResultSegment <TElement>(new List <TElement>()));
}
throw reqResult.Exception;
}
QueryOperationResponse response = dataServiceQueryResponse as QueryOperationResponse;
ResultSegment <TElement> retSeg = new ResultSegment <TElement>(dataServiceQueryResponse.ToList());
// Get continuation token from response
retSeg.ContinuationToken = TableUtilities.ContinuationFromResponse(response);
if (retSeg.ContinuationToken != null)
{
retSeg.ContinuationToken.TargetLocation = reqResult.TargetLocation;
}
return(retSeg);
}
private static SortedSet <string> GetCacheDependencies(
DbCommand command,
DbContext context,
CachePolicy cachePolicy)
{
if (command is null)
{
throw new ArgumentNullException(nameof(command));
}
if (cachePolicy is null)
{
throw new ArgumentNullException(nameof(cachePolicy));
}
var tableNames = new SortedSet <string>(
TableUtilities.GetTableNamesByContext(context).Select(x => x.TableName),
StringComparer.OrdinalIgnoreCase);
var textsInsideSquareBrackets = TableUtilities.GetSqlCommandTableNames(command.CommandText);
var cacheDependencies = new SortedSet <string>(
tableNames.Intersect(textsInsideSquareBrackets, StringComparer.OrdinalIgnoreCase),
StringComparer.OrdinalIgnoreCase);
if (cacheDependencies.Any())
{
return(cacheDependencies);
}
return(new SortedSet <string>());
}
public IEnumerable <TElement> Execute(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
{
requestOptions = TableRequestOptions.ApplyDefaults(requestOptions, this.Context.ServiceClient);
operationContext = operationContext ?? new OperationContext();
long takeCount = TableUtilities.GetQueryTakeCount(this.Query, long.MaxValue);
return(CommonUtility.LazyEnumerable(
(continuationToken) => this.ExecuteSegmentedCore((TableContinuationToken)continuationToken, requestOptions, operationContext),
takeCount));
}
/// <summary>
/// Tries to translate the specified exception into a storage exception.
/// </summary>
/// <param name="ex">The exception to translate.</param>
/// <param name="reqResult">The request result.</param>
/// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
/// <returns>The storage exception or <c>null</c>.</returns>
private static StorageException CoreTranslate(Exception ex, RequestResult reqResult, ref Func <Stream, StorageExtendedErrorInformation> parseError)
{
CommonUtility.AssertNotNull("reqResult", reqResult);
CommonUtility.AssertNotNull("ex", ex);
if (parseError == null)
{
parseError = StorageExtendedErrorInformation.ReadFromStream;
}
// Dont re-wrap storage exceptions
if (ex is StorageException)
{
return((StorageException)ex);
}
else if (ex is TimeoutException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.RequestTimeout;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
else if (ex is ArgumentException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.Unused;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex)
{
IsRetryable = false
});
}
#if WINDOWS_RT
else if (ex is OperationCanceledException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = 306; // unused
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
#elif WINDOWS_DESKTOP && !WINDOWS_PHONE
else
{
// Should never get to this one since we will call TranslateDataServiceException for DataService operations.
StorageException tableEx = TableUtilities.TranslateDataServiceException(ex, reqResult, null);
if (tableEx != null)
{
return(tableEx);
}
}
#endif
// return null and check in the caller
return(null);
}
/// <summary>
/// Translates the specified exception into a storage exception.
/// </summary>
/// <param name="ex">The exception to translate.</param>
/// <param name="reqResult">The request result.</param>
/// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
/// <returns>The storage exception.</returns>
internal static StorageException TranslateDataServiceException(Exception ex, RequestResult reqResult, Func <Stream, IDictionary <string, string>, StorageExtendedErrorInformation> parseError)
{
CommonUtility.AssertNotNull("reqResult", reqResult);
CommonUtility.AssertNotNull("ex", ex);
CommonUtility.AssertNotNull("parseError", parseError);
// Dont re-wrap storage exceptions
if (ex is StorageException)
{
return((StorageException)ex);
}
else if (ex is TimeoutException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.RequestTimeout;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
else if (ex is ArgumentException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.Unused;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex)
{
IsRetryable = false
});
}
else
{
StorageException tableEx = TableUtilities.TranslateDataServiceException(ex, reqResult, parseError);
if (tableEx != null)
{
return(tableEx);
}
}
// Just wrap in StorageException
return(new StorageException(reqResult, ex.Message, ex));
}
public static void TestingTables2() // TestingQueues2
{
TableUtilities tableUtil = new
TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Console.WriteLine("Insert entity ");
if (tableUtil.InsertEntity("sampletable",
new Contact("USA", "Pallmann") { LastName = "Pallmann", FirstName = "David",
Email = "*****@*****.**", Country = "USA" }))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
Console.WriteLine("Insert entity ");
if (tableUtil.InsertEntity("sampletable",
new Contact("USA", "Smith") { LastName = "Smith", FirstName = "John", Email =
"*****@*****.**", Country = "USA" }))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
Console.Write("Insert entity ");
if (tableUtil.InsertEntity("sampletable",
new Contact("USA", "Jones") { LastName = "Jones", FirstName = "Tom", Email =
"*****@*****.**", Country = "USA" }))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
Console.Write("Insert entity ");
if (tableUtil.InsertEntity("sampletable",
new Contact("USA", "Peters") { LastName = "Peters", FirstName = "Sally", Email =
"*****@*****.**", Country = "USA" }))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
}
private TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > GenerateExecuteCommand(TableContinuationToken continuationToken, TableRequestOptions requestOptions)
{
DataServiceQuery <TElement> localQuery = this.Query;
// Continuation
localQuery = TableUtilities.ApplyContinuationToQuery <TElement>(continuationToken, localQuery);
if (requestOptions.ServerTimeout.HasValue)
{
localQuery = localQuery.AddQueryOption("timeout", Convert.ToString(requestOptions.ServerTimeout.Value.TotalSeconds));
}
TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > cmd = new TableCommand <ResultSegment <TElement>, IEnumerable <TElement> >();
cmd.ExecuteFunc = localQuery.Execute;
cmd.Begin = (callback, state) => localQuery.BeginExecute(callback, state);
cmd.End = localQuery.EndExecute;
cmd.ParseResponse = this.ParseTableQueryResponse;
cmd.ApplyRequestOptions(requestOptions);
cmd.Context = this.Context;
return(cmd);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post")] ApplicationInfo info,
ILogger log)
{
var table = TableUtilities.GetCloudTable("Applications");
var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
var result = await table.ExecuteAsync(operation);
var application = result.Result as ApplicationEntity;
if (application != null)
{
return(new ConflictResult());
}
var query = table.CreateQuery <ApplicationEntity>()
.Where(p => p.PartitionKey.Equals(info.GroupId))
.AsTableQuery();
var entities = await table.ExecuteQueryAsync(query);
if (entities.Count > 0 && entities.First().Password.Equals(info.Password) == false)
{
return(new UnauthorizedResult());
}
operation = TableOperation.Insert(new ApplicationEntity
{
PartitionKey = info.GroupId,
RowKey = info.ApplicationId,
MachineName = info.MachineName,
Password = info.Password
});
await table.ExecuteAsync(operation);
return(new NoContentResult());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] ChangePasswordInfo info,
ILogger log)
{
var table = TableUtilities.GetCloudTable("Applications");
var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
var result = await table.ExecuteAsync(operation);
var application = result.Result as ApplicationEntity;
if (application == null)
{
return(new NotFoundResult());
}
if (application.Password.Equals(info.Password) == false)
{
return(new UnauthorizedResult());
}
var query = table.CreateQuery <ApplicationEntity>()
.Where(p => p.PartitionKey.Equals(info.GroupId))
.AsTableQuery();
var entities = await table.ExecuteQueryAsync(query);
var batch = new TableBatchOperation();
foreach (var entity in entities)
{
entity.Password = info.NewPassword;
batch.Replace(entity);
}
await table.ExecuteBatchAsync(batch);
return(new NoContentResult());
}
/// <summary>
/// Translates the specified exception into a storage exception.
/// </summary>
/// <param name="ex">The exception to translate.</param>
/// <param name="reqResult">The request result.</param>
/// <returns>The storage exception.</returns>
public static StorageException TranslateException(Exception ex, RequestResult reqResult)
{
// Dont re-wrap storage exceptions
if (ex is StorageException)
{
return((StorageException)ex);
}
else if (ex is TimeoutException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.Unused;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
else if (ex is ArgumentException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.Unused;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex)
{
IsRetryable = false
});
}
#if RT || XAMARIN
else if (ex is OperationCanceledException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = 306; // unused
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
#elif DNCP
else
{
StorageException tableEx = TableUtilities.TranslateDataServiceClientException(ex, reqResult);
if (tableEx != null)
{
return(tableEx);
}
}
#endif
WebException we = ex as WebException;
if (we != null)
{
try
{
HttpWebResponse response = we.Response as HttpWebResponse;
if (response != null)
{
reqResult.HttpStatusMessage = response.StatusDescription;
reqResult.HttpStatusCode = (int)response.StatusCode;
if (response.Headers != null)
{
#if DNCP
reqResult.ServiceRequestID = HttpUtility.TryGetHeader(response, Constants.HeaderConstants.RequestIdHeader, null);
reqResult.ContentMd5 = HttpUtility.TryGetHeader(response, "Content-MD5", null);
string tempDate = HttpUtility.TryGetHeader(response, "Date", null);
reqResult.RequestDate = string.IsNullOrEmpty(tempDate) ? DateTime.Now.ToString("R", CultureInfo.InvariantCulture) : tempDate;
reqResult.Etag = response.Headers[HttpResponseHeader.ETag];
#endif
}
#if RT
reqResult.ExtendedErrorInformation = StorageExtendedErrorInformation.ReadFromStream(response.GetResponseStream().AsInputStream());
#else
reqResult.ExtendedErrorInformation = StorageExtendedErrorInformation.ReadFromStream(response.GetResponseStream());
#endif
}
}
catch (Exception)
{
// no op
}
}
// Not WebException, just wrap in StorageException
return(new StorageException(reqResult, ex.Message, ex));
}
public static void TestingTables4()
{
TableUtilities tableUtil = new
TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Console.Write("Merge Update entity. Preserves the unchanged properties. ");
if (tableUtil.MergeUpdateEntity("sampletable", "USA", "Peters",
new MiniContact("USA", "Peters")
{
LastName = "Peters",
FirstName = "Sally",
Email =
"*****@*****.**"
}))
Console.WriteLine("true");
else
Console.WriteLine("false");
}
public static void TestingTables5()
{
TableUtilities tableUtil = new
TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Contact contact = null;
Separator();
Console.Write("Get entity ");
if (tableUtil.GetEntity<Contact>("sampletable", "USA", "Pallmann", out contact))
{
Console.WriteLine("true");
if (contact != null)
{
Console.WriteLine("Contact.LastName: " + contact.LastName);
Console.WriteLine("Contact.FirstName: " + contact.FirstName);
Console.WriteLine("Contact.Email: " + contact.Email);
Console.WriteLine("Contact.Phone: " + contact.Phone);
Console.WriteLine("Contact.Country: " + contact.Country);
}
else
Console.WriteLine("Contact <NULL>");
}
else
Console.WriteLine("false");
Separator();
//Contact
contact = null;
Console.Write("Get entity ");
if (tableUtil.GetEntity<Contact>("sampletable", "USA", "Smith", out contact))
{
Console.WriteLine("true");
if (contact != null)
{
Console.WriteLine("Contact.LastName: " + contact.LastName);
Console.WriteLine("Contact.FirstName: " + contact.FirstName);
Console.WriteLine("Contact.Email: " + contact.Email);
Console.WriteLine("Contact.Phone: " + contact.Phone);
Console.WriteLine("Contact.Country: " + contact.Country);
}
else
Console.WriteLine("Contact <NULL>");
}
else
{
Console.WriteLine("false");
}
Separator();
}
public static void TestingTables6()
{
TableUtilities tableUtil = new
TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Console.Write("Query entities ");
IEnumerable<Contact> entities = tableUtil.QueryEntities<Contact>("sampletable").Where(e =>
e.PartitionKey == "USA").AsTableServiceQuery<Contact>();
if (entities != null)
{
Console.WriteLine("true");
foreach (Contact contact1 in entities)
{
Console.WriteLine("Contact.LastName: " + contact1.LastName);
Console.WriteLine("Contact.FirstName: " + contact1.FirstName);
Console.WriteLine("Contact.Email: " + contact1.Email);
Console.WriteLine("Contact.Phone: " + contact1.Phone);
Console.WriteLine("Contact.Country: " + contact1.Country);
Console.WriteLine();
}
}
else
Console.WriteLine("<NULL>");
}
public static void TestingTables3()
{
TableUtilities tableUtil = new TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Console.Write("Update entity ");
if (tableUtil.ReplaceUpdateEntity("sampletable", "USA", "Pallmann",
new Contact("USA", "Pallmann")
{
LastName = "Pallmann",
FirstName = "David",
Email =
"*****@*****.**",
Country = "USA"
}))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
Console.Write("Replace Update entity ");
if (tableUtil.ReplaceUpdateEntity("sampletable", "USA", "Peters",
new Contact("USA", "Peters")
{
LastName = "Peters",
FirstName = "Sally",
Country = "USA"
}))
Console.WriteLine("true");
else
Console.WriteLine("false");
Separator();
}
public static void TestingTables7()
{
TableUtilities tableUtil = new
TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
Separator();
Console.Write("Delete entity ");
if (tableUtil.DeleteEntity<Contact>("sampletable", "USA", "Smith"))
Console.WriteLine("true");
else
Console.WriteLine("false");
}
