internal static void SaveCoreTableItemSync <T>(T item, string tableName) where T : TableEntity
{
var table = TableUtil.GetCoreTableReference(tableName);
var saveOperation = TableOperation.InsertOrReplace(item);
table.Execute(saveOperation);
}
public async Task DeletePolicyLookupPath(string subscriptionId, string policyName)
{
var item = new PolicyLookupPathEntity {
PartitionKey = subscriptionId, RowKey = policyName
};
await TableUtil.DeleteTableItem(item, Tables.PolicyLookupPaths);
}
internal async Task <Organization> GetOrganization(string organizationId)
{
var table = TableUtil.GetCoreTableReference(Tables.Organizations);
var retrieveOperation = TableOperation.Retrieve <Organization>(partitionKey, organizationId);
var tableResult = await table.ExecuteAsync(retrieveOperation);
return((Organization)tableResult.Result);
}
internal Subscription GetSubscription(string subscriptionID)
{
var table = TableUtil.GetCoreTableReference(typeof(Subscription).Name);
var retrieveOperation = TableOperation.Retrieve <Subscription>(partitionKey, subscriptionID);
var tableResult = table.Execute(retrieveOperation);
return((Subscription)tableResult.Result);
}
public async Task <List <PolicyLookupPathEntity> > GetPolicyLookupPaths(string subscriptionId)
{
var table = await TableUtil.GetTableReference(Tables.PolicyLookupPaths);
TableQuery <PolicyLookupPathEntity> query = new TableQuery <PolicyLookupPathEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, subscriptionId));
var result = table.ExecuteQuery(query).ToList();
return(result);
}
public async Task <string> GetPolicyLookupPath(string subscriptionId, string policyName)
{
var table = await TableUtil.GetTableReference(Tables.PolicyLookupPaths);
var retrieveOperation = TableOperation.Retrieve <PolicyLookupPathEntity>(subscriptionId, policyName);
var tableResult = await table.ExecuteAsync(retrieveOperation);
return((tableResult.Result as PolicyLookupPathEntity)?.PolicyLookupPath);
}
public async Task <string> SavePolicyLookupPath(string subscriptionId, string policyName, string lookupPath)
{
var lookupPathEntity = new PolicyLookupPathEntity {
PartitionKey = subscriptionId, RowKey = policyName, PolicyLookupPath = lookupPath
};
var policyLookupEntity = await TableUtil.SaveTableItem(lookupPathEntity, Tables.PolicyLookupPaths);
return(policyLookupEntity.PolicyLookupPath);
}
internal async Task SaveOrganization(Organization organization)
{
organization.VerifiedDomain = organization.VerifiedDomain.ToLower();
if (!organization.EnrolledDate.HasValue)
{
organization.EnrolledDate = DateTime.Now;
}
await TableUtil.SaveCoreTableItem(organization, Tables.Organizations);
}
internal static async Task DeleteTableItem <T>(T item, string tableName) where T : TableEntity
{
item.PartitionKey = item.PartitionKey ?? "Admin";
item.ETag = "*";
var table = await TableUtil.GetTableReference(tableName);
var deleteOperation = TableOperation.Delete(item);
await table.ExecuteAsync(deleteOperation);
}
internal static async Task <T> SaveTableItem <T>(T item, string tableName) where T : TableEntity
{
var table = await TableUtil.GetTableReference(tableName);
var saveOperation = TableOperation.InsertOrReplace(item);
var tableResult = await table.ExecuteAsync(saveOperation);
return((T)tableResult.Result);
}
internal async Task DeleteOrganization(Organization organization)
{
List <Subscription> relatedSubscriptions = GetSubscriptionListByOrgId(organization.Id);
await TableUtil.DeleteCoreTableItem(organization, Tables.Organizations);
//Delete all subscriptions associated with the organization
foreach (Subscription relatedSubscription in relatedSubscriptions)
{
await DeleteSubscription(relatedSubscription);
}
}
internal List <Subscription> GetSubscriptionListByOrgId(string orgID)
{
var table = TableUtil.GetCoreTableReference(typeof(Subscription).Name);
var query = new TableQuery <Subscription>().Where(TableQuery.GenerateFilterCondition("OrganizationId", QueryComparisons.Equal, orgID));
var result = table.ExecuteQuery(query);
if (result != null)
{
return(result.ToList());
}
return(null);
}
internal List <PerUserTokenCache> GetPerUserTokenCacheListById(string User)
{
var table = TableUtil.GetCoreTableReference(Tables.PerUserTokenCache);
var query = new TableQuery <PerUserTokenCache>().Where(TableQuery.GenerateFilterCondition("webUserUniqueId", QueryComparisons.Equal, User));
var result = table.ExecuteQuery(query);
if (result != null)
{
return(result.ToList());
}
return(null);
}
/// <summary>
/// This implementation uses Wintellect Azure Table library to overcome the limitation of 32KB for string attributes.
/// The ARM template data is now stored as bytes and Wintellect library is used to automatically split and join the byte array based on pre-defined number of splits.
/// Refer <see cref="TemplateEntity"/> for implementation details
/// </summary>
public async Task <TemplateViewModel> GetTemplate(string templateName)
{
var table = await TableUtil.GetTableReference(Tables.Products);
var azTable = new AzureTable(table);
var dynamicTemplateEntity = await TemplateEntity.FindAsync(azTable, partitionKey, templateName);
var templateViewModel = new TemplateEntity(azTable, dynamicTemplateEntity);
return(TemplateEntity.MapToViewModel(templateViewModel));
}
internal Organization GetOrganizationByDomain(string domain)
{
var table = TableUtil.GetCoreTableReference(Tables.Organizations);
var filter = TableQuery.GenerateFilterCondition("VerifiedDomain", QueryComparisons.Equal, domain);
var query = new TableQuery <Organization>().Where(filter);
var result = table.ExecuteQuery(query);
if (result != null)
{
return(result.SingleOrDefault());
}
return(null);
}
/// <summary>
/// This implementation uses Wintellect Azure Table library to overcome the limitation of 32KB for string attributes.
/// The ARM template data is now stored as bytes and Wintellect library is used to automatically split and join the byte array based on pre-defined number of splits.
/// Refer <see cref="TemplateEntity"/> for implementation details
/// </summary>
public async Task DeleteTemplate(string rowKey)
{
var table = await TableUtil.GetTableReference(Tables.Products);
var azTable = new AzureTable(table);
var templateEntity = new TemplateEntity(azTable);
templateEntity.RowKey = rowKey;
templateEntity.PartitionKey = partitionKey;
templateEntity.ETag = "*";
await templateEntity.DeleteAsync();
}
internal List <Subscription> GetEnrolledSubscriptionListByOrgId(string orgID)
{
var table = TableUtil.GetCoreTableReference(Tables.Subscription);
string orgFilter = TableQuery.GenerateFilterCondition("OrganizationId", QueryComparisons.Equal, orgID);
string isEnrolledFilter = TableQuery.GenerateFilterConditionForBool("IsEnrolled", QueryComparisons.Equal, true);
string combinedFilters = TableQuery.CombineFilters(orgFilter, TableOperators.And, isEnrolledFilter);
var query = new TableQuery <Subscription>().Where(combinedFilters);
var result = table.ExecuteQuery(query);
if (result != null)
{
return(result.ToList());
}
return(null);
}
/// <summary>
/// This implementation uses Wintellect Azure Table library to overcome the limitation of 32KB for string attributes.
/// The ARM template data is now stored as bytes and Wintellect library is used to automatically split and join the byte array based on pre-defined number of splits.
/// Refer <see cref="TemplateEntity"/> for implementation details
/// </summary>
public async Task <TemplateViewModel> SaveTemplate(TemplateViewModel template)
{
template.PartitionKey = partitionKey;
template.ProductImagePath = await SaveProductImageAsBlob(template.ProductImage);
template.ProductImage = null; //Null out the base64 data
var table = await TableUtil.GetTableReference(Tables.Products);
var azTable = new AzureTable(table);
var templateEntity = TemplateEntity.MapFromViewModel(template, azTable);
var tableResult = await templateEntity.InsertOrReplaceAsync();
var templateViewModel = TemplateEntity.MapToViewModel((TemplateEntity)tableResult.Result);
return(templateViewModel);
}
/// <summary>
/// This implementation uses Wintellect Azure Table library to overcome the limitation of 32KB for string attributes.
/// The ARM template data is now stored as bytes and Wintellect library is used to automatically split and join the byte array based on pre-defined number of splits.
/// Refer <see cref="TemplateEntity"/> for implementation details
/// </summary>
public async Task <List <TemplateViewModel> > GetTemplates()
{
var query = new TableQuery();
query.FilterString = new TableFilterBuilder <TemplateEntity>()
.And(te => te.PartitionKey, CompareOp.EQ, partitionKey);
var table = await TableUtil.GetTableReference(Tables.Products);
var azTable = new AzureTable(table);
var dynamicTemplateEntities = table.ExecuteQuery(query);
var templateList = new List <TemplateViewModel>();
foreach (var entity in dynamicTemplateEntities)
{
var templateEntity = new TemplateEntity(azTable, entity);
templateList.Add(TemplateEntity.MapToViewModel(templateEntity));
}
return(templateList);
}
internal void SavePerUserTokenCaches(PerUserTokenCache cache)
{
TableUtil.SaveCoreTableItemSync <PerUserTokenCache>(cache, Tables.PerUserTokenCache);
}
internal async Task SaveSubscription(Subscription subscription)
{
await TableUtil.SaveCoreTableItem(subscription, Tables.Subscription);
}
internal async Task DeleteSubscription(Subscription subscription)
{
await TableUtil.DeleteCoreTableItem(subscription, Tables.Subscription);
}
internal static async Task SaveCoreTableItem <T>(T item, string tableName) where T : TableEntity
{
var table = TableUtil.GetCoreTableReference(tableName);
var saveOperation = TableOperation.InsertOrReplace(item);
await table.ExecuteAsync(saveOperation);
}
internal static async Task DeleteCoreTableItem <T>(T item, string tableName) where T : TableEntity
{
var table = TableUtil.GetCoreTableReference(tableName);
var deleteOperation = TableOperation.Delete(item);
await table.ExecuteAsync(deleteOperation);
}
