public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetFriends/{myPublicKey}")] HttpRequest req,
string myPublicKey,
[Table("Friend")] CloudTable friendTable,
[Table("User")] CloudTable userTable,
ILogger log)
{
log.LogInformation($"C# HTTP trigger {nameof(SubmitFriendRequest)} function processed a request.");
var privateKey = Utils.ParseToken(req);
if (privateKey == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized)
{
Content = new StringContent("You are not authorized to make this request.")
}
}
;
if (string.IsNullOrWhiteSpace(myPublicKey))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Invalid data to process request")
});
}
try
{
var user = await Utils.FindUserEntitySlim(userTable, privateKey, myPublicKey);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Unable to locate your user account.")
}
}
;
}
catch (Exception ex)
{
log.LogInformation("User doesn't exist: " + ex.Message);
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Unable to locate your user account.")
});
}
var statuses = new List <FriendStatus>();
try
{
var publicKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey",
QueryComparisons.Equal, myPublicKey);
var rangeQuery = new TableQuery <FriendEntity>().Where(publicKeyFilter);
var friends = await friendTable.ExecuteQuerySegmentedAsync(rangeQuery, null);
// spin off tasks for finding all friends
var tasks = new List <Task <TableQuerySegment <UserEntity> > >();
foreach (var f in friends)
{
tasks.Add(Utils.FindFriendTask(userTable, f.RequesteePublicKey));
}
await Task.WhenAll(tasks);
foreach (var t in tasks)
{
var friend = t.Result?.Results?.FirstOrDefault();
if (friend == null)
{
continue;
}
var friendCode = string.Empty;
try
{
friendCode = Cipher.Decrypt(friend.FriendCode, Utils.FriendCodePassword, friend.PublicKey);
}
catch (Exception ex)
{
log.LogError("Unable to decrypt friendcode: " + ex.Message);
}
statuses.Add(new FriendStatus
{
AMPrice = friend.AMPrice,
BuyPrice = friend.BuyPrice,
Fruit = friend.Fruit,
IslandName = friend.IslandName,
Name = friend.Name,
PMPrice = friend.PMPrice,
PublicKey = friend.PublicKey,
Status = friend.Status,
TimeZone = friend.TimeZone,
TurnipUpdateDayOfYear = friend.TurnipUpdateDayOfYear,
TurnipUpdateTimeUTC = friend.TurnipUpdateTimeUTC,
TurnipUpdateYear = friend.TurnipUpdateYear,
FriendCode = friendCode,
MaxPrediction = friend.MaxPrediction,
MinPrediction = friend.MinPrediction,
DodoCode = friend.DodoCode ?? string.Empty,
GateClosesAtUTC = friend.GateClosesAtUTC.HasValue ? friend.GateClosesAtUTC.Value : DateTime.UtcNow,
GateStatus = friend.GateStatus
});
}
}
catch (Exception ex)
{
log.LogError($"Error {nameof(GetFriends)} - Error: " + ex.Message);
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
}
var json = JsonConvert.SerializeObject(statuses);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
});
}
}
public async Task <T[]> GetAllAsync(TableQuery <T> query)
{
var result = await _tableClient.ExecuteQuerySegmentedAsync(query, null);
return(result.Results.ToArray());
}
public AzureUtils GetSearchResult(string rowPropertyName, string expectedPropertyValue)
{
tableSegment = cloudTable.ExecuteQuerySegmentedAsync(
new TableQuery().Where(TableQuery.GenerateFilterCondition(rowPropertyName, QueryComparisons.Equal, expectedPropertyValue)), null).Result;
return(this);
}
public async Task <ObjectHistoryEntity> GetLastObjectHistoryEntity(string partitionKey, CloudTable table)
{
var query = new TableQuery <ObjectHistoryEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
return((await table.ExecuteQuerySegmentedAsync(query.Take(1), null)).SingleOrDefault());
}
/// <inheritdoc /> protected override async Task <TableQuerySegment <TElement> > ExecuteAsync(TableQuery <TElement> query, TableContinuationToken token) => await _cloudTable.ExecuteQuerySegmentedAsync(query, token);
// Overload 2
public static Task <TableQuerySegment <T> > ExecuteQuerySegmentedAsync <T>(this CloudTable tbl, TableQuery <T> query, TableContinuationToken continuationToken, CancellationToken token) where T : ITableEntity, new()
{
return(tbl.ExecuteQuerySegmentedAsync <T>(query, continuationToken, null, null, token));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
[Table("PRIssueMapping")] CloudTable table,
[Table("IssueRepoMapping")] CloudTable table2,
[Table("GroupPrefix")] CloudTable table3,
ILogger log)
{
var PRs = new List <string>();
var Repos = new List <RepoInfo>();
var PullInfo = new List <PR>();
dynamic data = JObject.Parse(await new StreamReader(req.Body).ReadToEndAsync());
string RowKey = data.key;
string prefix = "";
string urlName = "";
HttpClient client = new HttpClient();
string url = "";
var byteArray = Encoding.ASCII.GetBytes($":{Environment.GetEnvironmentVariable("AzureDevOps_Setting", EnvironmentVariableTarget.Process)}");
TableQuery <PRIssueMapping> rangeQuery = new TableQuery <PRIssueMapping>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, RowKey));
foreach (PRIssueMapping issue in await table.ExecuteQuerySegmentedAsync(rangeQuery, null))
{
string[] issueSplit = issue.PartitionKey.Split("|");
prefix = issueSplit[0];
PRs.Add(issueSplit[1]);
}
string[] PRArray = PRs.ToArray();
TableQuery <GroupPrefix> rangeQuery3 = new TableQuery <GroupPrefix>().Where(TableQuery.GenerateFilterCondition("Prefix", QueryComparisons.Equal, prefix));
foreach (GroupPrefix repo in await table3.ExecuteQuerySegmentedAsync(rangeQuery3, null))
{
string[] urlSplit = repo.PartitionKey.Split(" ");
urlName = urlSplit[1];
}
string PartitionKey = $"{prefix}|{RowKey}";
TableQuery <PRRepoMapping> rangeQuery2 = new TableQuery <PRRepoMapping>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PartitionKey));
foreach (PRRepoMapping repo in await table2.ExecuteQuerySegmentedAsync(rangeQuery2, null))
{
url = $"https://dev.azure.com/{urlName}/_apis/git/repositories/{repo.RowKey}?api-version=4.1";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
HttpResponseMessage response = await client.SendAsync(request);
dynamic repoJSON = JObject.Parse(await response.Content.ReadAsStringAsync());
string name = repoJSON.name;
Repos.Add(new RepoInfo()
{
status = repo.MergeStatus, repoName = name
});
}
RepoInfo[] RepoArray = Repos.ToArray();
foreach (string PR in PRArray)
{
url = $"https://dev.azure.com/{urlName}/_apis/git/pullrequests/{PR}?api-version=5.1";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
HttpResponseMessage response = await client.SendAsync(request);
dynamic titleJSON = JObject.Parse(await response.Content.ReadAsStringAsync());
string title = titleJSON.repository.name;
PullInfo.Add(new PR()
{
ID = PR, name = urlName, repoTitle = title
});
}
PR[] pullInfo = PullInfo.ToArray();
return(new OkObjectResult(new PRAndRepoResponse()
{
PullRequests = pullInfo, Repos = RepoArray
}));
}
public static async Task <string> GetActionRequest(//*
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "get-action-request/{act}/{user}/{owner}/{plateNum}")] HttpRequestMessage request,
string user,
string act,
string owner,
string plateNum,
[SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
log.LogInformation("GetActionRequest");
//addition
CloudTable table = null;
CloudTableClient client = null;
//first get all users
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
client = account.CreateCloudTableClient();
table = client.GetTableReference("Requests");
await table.CreateIfNotExistsAsync();
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
if (act.Equals("add"))
{
//check if it's a new request
List <Request> requestList = await GetRequests(table, user, true, null);
string idQuery = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, plateNum);
TableQuery <Request> query = new TableQuery <Request>().Where(idQuery);
var results = await table.ExecuteQuerySegmentedAsync <Request>(query, null);
foreach (Request e in results.Results)
{
if (e.approved.Equals("waiting"))
{
if (e.PartitionKey.Equals(user))
{
return("Failed : the Request arleady suggested ");
}
else
{
return("Failed : the Request arleady suggested by another user");
}
}
}
//check if the car arleady regestered
List <User> cars = await GetRegesteredCar(null, "admin", null);
foreach (User e in cars)
{
if (e.RowKey.Equals(plateNum))
{
if (e.UserName.Equals(user))
{
return("Failed : the car arleady registered by you ");
}
else
{
return("Failed : the car arleady registered by another user ");
}
}
}
Request newRequest = new Request();
newRequest.PartitionKey = user;
newRequest.RowKey = plateNum;
newRequest.ownerName = owner;
newRequest.approved = "waiting";
TableOperation add = TableOperation.InsertOrReplace(newRequest);
await table.ExecuteAsync(add);
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "requestUpdate",
Arguments = new[] { "add" }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "AddRequestNotify",
Arguments = new[] { user }
});
}
else
{//remove
TableOperation retrieve = TableOperation.Retrieve <Request>(user, plateNum);
TableResult result = await table.ExecuteAsync(retrieve);
var deleteEntity = (Request)result.Result;
TableOperation delete = TableOperation.Delete(deleteEntity);
await table.ExecuteAsync(delete);
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "requestUpdate",
Arguments = new[] { "remove:" + plateNum }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "RemoveRequestNotify",
Arguments = new[] { user }
});
}
return(act);
}
public static dynamic GetAzureStorageListingsCore(HttpRequest req, Logging logging)
{
string requestBody = new System.IO.StreamReader(req.Body).ReadToEndAsync().Result;
dynamic taskInformation = JsonConvert.DeserializeObject(requestBody);
string _TaskInstanceId = taskInformation["TaskInstanceId"].ToString();
string _ExecutionUid = taskInformation["ExecutionUid"].ToString();
try
{
string _storageAccountName = taskInformation["Source"]["StorageAccountName"];
//The name is actually the base url so we need to parse it to get the name only
_storageAccountName = _storageAccountName.Split('.')[0].Replace("https://", "");
string _storageAccountToken = taskInformation["Source"]["StorageAccountToken"];
Int64 _SourceSystemId = taskInformation["Source"]["SystemId"];
TaskMetaDataDatabase TMD = new TaskMetaDataDatabase();
using SqlConnection _con = TMD.GetSqlConnection();
var res = _con.QueryWithRetry(string.Format("Select Max(PartitionKey) MaxPartitionKey from AzureStorageListing where SystemId = {0}", _SourceSystemId.ToString()));
string MaxPartitionKey = DateTime.UtcNow.AddDays(-1).ToString("yyyy-MM-dd hh:mm");
foreach (var r in res)
{
if (r.MaxPartitionKey != null)
{
MaxPartitionKey = DateTime.Parse(r.MaxPartitionKey).AddMinutes(-1).ToString("yyyy-MM-dd hh:mm");
}
}
using (HttpClient SourceClient = new HttpClient())
{
//Now use the SAS URI to connect rather than the MSI / Service Principal as AD Based Auth not yet avail for tables
var _storageCredentials = new StorageCredentials(_storageAccountToken);
var SourceStorageAccount = new CloudStorageAccount(storageCredentials: _storageCredentials, accountName: _storageAccountName, endpointSuffix: "core.windows.net", useHttps: true);
var client = SourceStorageAccount.CreateCloudTableClient();
CloudTable table = client.GetTableReference("Filelist");
TableQuery <DynamicTableEntity> query = new TableQuery <DynamicTableEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThan, MaxPartitionKey.ToString()));
DataTable dt = new DataTable();
DataColumn dc = new DataColumn();
dc.ColumnName = "PartitionKey";
dc.DataType = typeof(string);
dt.Columns.Add(dc);
DataColumn dc1 = new DataColumn();
dc1.ColumnName = "RowKey";
dc1.DataType = typeof(string);
dt.Columns.Add(dc1);
DataColumn dc2 = new DataColumn();
dc2.ColumnName = "SystemId";
dc2.DataType = typeof(Int64);
dt.Columns.Add(dc2);
DataColumn dc3 = new DataColumn();
dc3.ColumnName = "FilePath";
dc3.DataType = typeof(string);
dt.Columns.Add(dc3);
string Filelist = "";
TableContinuationToken token = null;
do
{
TableQuerySegment <DynamicTableEntity> resultSegment = table.ExecuteQuerySegmentedAsync(query, token).Result;
token = resultSegment.ContinuationToken;
//load into data table
foreach (var entity in resultSegment.Results)
{
DataRow dr = dt.NewRow();
dr["PartitionKey"] = entity.PartitionKey;
dr["RowKey"] = entity.RowKey;
dr["SystemId"] = _SourceSystemId;
dr["FilePath"] = entity.Properties["FilePath"].StringValue;
dt.Rows.Add(dr);
Filelist += entity.Properties["FilePath"].StringValue + System.Environment.NewLine;
}
} while (token != null);
if (dt.Rows.Count > 0)
{
Table t = new Table();
t.Schema = "dbo";
string TableGuid = Guid.NewGuid().ToString();
t.Name = $"#AzureStorageListing{TableGuid}";
TMD.BulkInsert(dt, t, true, _con);
Dictionary <string, string> SqlParams = new Dictionary <string, string>
{
{ "TempTable", t.QuotedSchemaAndName() },
{ "SourceSystemId", _SourceSystemId.ToString() }
};
string MergeSQL = GenerateSQLStatementTemplates.GetSQL(System.IO.Path.Combine(Shared._ApplicationBasePath, Shared._ApplicationOptions.LocalPaths.SQLTemplateLocation), "MergeIntoAzureStorageListing", SqlParams);
_con.ExecuteWithRetry(MergeSQL, 120);
if ((JArray)taskInformation["Alerts"] != null)
{
foreach (JObject Alert in (JArray)taskInformation["Alerts"])
{
//Only Send out for Operator Level Alerts
if (Alert["AlertCategory"].ToString() == "Task Specific Operator Alert")
{
AlertOperator(_SourceSystemId, Alert["AlertEmail"].ToString(), "", Filelist);
}
}
}
}
_con.Close();
_con.Dispose();
TMD.LogTaskInstanceCompletion(System.Convert.ToInt64(_TaskInstanceId), System.Guid.Parse(_ExecutionUid), TaskMetaData.BaseTasks.TaskStatus.Complete, Guid.Empty, "");
}
}
catch (Exception e)
{
logging.LogErrors(e);
TaskMetaDataDatabase TMD = new TaskMetaDataDatabase();
TMD.LogTaskInstanceCompletion(System.Convert.ToInt64(_TaskInstanceId), System.Guid.Parse(_ExecutionUid), TaskMetaData.BaseTasks.TaskStatus.FailedRetry, Guid.Empty, "Failed when trying to Generate Sas URI and Send Email");
JObject Root = new JObject
{
["Result"] = "Failed"
};
return(Root);
}
return(new { });
}
internal async Task <QueryResult <T> > QueryAsyncInternalSinglePage <T>(string partitionKey, string rowKey, IEnumerable <QueryFilter> queryFilters = null, int maxItems = 0, TableContinuationToken continuationToken = null) where T : new()
{
try
{
// notify delegate
if (_delegate != null)
{
_delegate.OnQuerying(typeof(T), partitionKey, rowKey, maxItems, continuationToken != null);
}
// Retrieve a reference to the table.
CloudTable table = GetTableReference(GetTableName <T>());
// lookup the entitymapper
var entityMapper = _entityMapperRegistry[typeof(T)];
// Construct the query to get all entries
TableQuery <DynamicTableEntity <T> > query = new TableQuery <DynamicTableEntity <T> >();
// add partitionkey if exists
string partitionKeyFilter = null;
if (partitionKey != null)
{
partitionKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
}
// add row key if exists
string rowKeyFilter = null;
if (rowKey != null)
{
rowKeyFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey);
}
// define the max query items
if (maxItems > 0)
{
query = query.Take(maxItems);
}
// build the query filter
if (partitionKey != null && rowKey != null)
{
query = query.Where(TableQuery.CombineFilters(partitionKeyFilter, TableOperators.And, rowKeyFilter));
}
else if (partitionKey != null && rowKey == null)
{
query = query.Where(partitionKeyFilter);
}
else if (partitionKey == null && rowKey != null)
{
throw new Exception("PartitionKey must have a value");
}
// build the final query filter
if (queryFilters != null)
{
foreach (var queryFilter in queryFilters)
{
var generatedQueryFilter = queryFilter.ToString();
if (String.IsNullOrEmpty(query.FilterString))
{
query.Where(generatedQueryFilter);
}
else if (queryFilter.FilterType == QueryFilterType.Where || queryFilter.FilterType == QueryFilterType.And)
{
query.Where(TableQuery.CombineFilters(query.FilterString, TableOperators.And, generatedQueryFilter));
}
else if (queryFilter.FilterType == QueryFilterType.Or)
{
query.Where(TableQuery.CombineFilters(query.FilterString, TableOperators.Or, generatedQueryFilter));
}
}
}
// execute the query
var queryResult = await table.ExecuteQuerySegmentedAsync(query, continuationToken);
// map all to the original models
List <T> result = new List <T>();
foreach (DynamicTableEntity <T> model in queryResult)
{
result.Add(model.Model);
}
// notify delegate
if (_delegate != null)
{
_delegate.OnQueryed(typeof(T), partitionKey, rowKey, maxItems, continuationToken != null, null);
}
// done
return(new QueryResult <T>()
{
Items = result.AsQueryable(),
NextToken = queryResult.ContinuationToken
});
} catch (Exception e) {
// check if we have autocreate
if (_autoCreateTable || e.Message.StartsWith("0:The table specified does not exist", StringComparison.CurrentCulture))
{
// notify delegate
if (_delegate != null)
{
_delegate.OnQueryed(typeof(T), partitionKey, rowKey, maxItems, continuationToken != null, null);
}
// done
return(new QueryResult <T>()
{
Items = new List <T>().AsQueryable <T>(),
NextToken = null
});
}
else
{
// notify delegate
if (_delegate != null)
{
_delegate.OnQueryed(typeof(T), partitionKey, rowKey, maxItems, continuationToken != null, e);
}
// throw exception
throw e;
}
}
}
public static async Task <bool> MakeQueueAsync(ILogger logger)
{
Settings settings = Settings.Load();
CloudStorageAccount account = CloudStorageAccount.Parse(settings.AzureWebJobsStorage);
CloudTableClient tableClient = account.CreateCloudTableClient();
CloudQueueClient queueClient = account.CreateCloudQueueClient();
CloudQueue jobQueue = queueClient.GetQueueReference(settings.JobQueueName);
_ = await jobQueue.CreateIfNotExistsAsync();
CloudTable jobTable = tableClient.GetTableReference(settings.JobTableName);
CloudTable jobHistoryTable = tableClient.GetTableReference(settings.JobHistoryTableName);
_ = await jobHistoryTable.CreateIfNotExistsAsync();
JobEntity plan = null;
{
TableQuery <JobEntity> query = new TableQuery <JobEntity>().Take(8);
TableQuerySegment <JobEntity> segments = await jobTable.ExecuteQuerySegmentedAsync(query, null);
var jobEntities = segments.Results;
var ordered = jobEntities.OrderByDescending(i => i.CreateAt);
if (ordered.Count() == 0)
{
return(true);
}
plan = ordered.First();
}
int step = int.Parse(settings.Step);
if (step <= 0)
{
step = DEFAULT_STEP;
}
{
string targetPath = settings.TargetPath;
Uri uri = new Uri(targetPath);
CloudBlobContainer blobContainer = new CloudBlobContainer(uri, account.Credentials);
int section = plan.Current / step;
string path = $"{plan.Version}/{plan.PartitionKey}/{section * step}";
long fileCount = await StorageHelper.GetBlobFileCountAsync(blobContainer, path, int.Parse(settings.MaxResult));
if (fileCount <= int.Parse(settings.StepThreshold) && fileCount > 0)
{
logger.LogInformation($"file count {fileCount} less than step threshold");
return(true);
}
}
if (plan.Current >= plan.Amount)
{
TableOperation delete = TableOperation.Delete(plan);
_ = await jobTable.ExecuteAsync(delete);
plan.UpdateAt = DateTime.Now;
TableOperation insertOrMerge = TableOperation.InsertOrMerge(plan);
_ = await jobHistoryTable.ExecuteAsync(insertOrMerge);
return(true);
}
else
{
int start = plan.Current;
int current = plan.Current + step;
int count = step;
if (current > plan.Amount)
{
count = plan.Amount - plan.Current;
plan.Current = plan.Amount;
}
else
{
plan.Current += step;
}
plan.UpdateAt = DateTime.Now;
TableOperation insertOrMerge = TableOperation.InsertOrMerge(plan);
_ = await jobTable.ExecuteAsync(insertOrMerge);
MakeQueueMessageAsync(jobQueue, plan, start, count, settings.SourcePath, settings.TargetPath);
}
return(true);
}
public async Task RemoveFromAllRolesAsync(T user)
{
bool error = false;
List <TableUserRole> roles = new List <TableUserRole>();
string partitionKeyQuery = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, user.Id);
TableQuery <TableUserRole> query = new TableQuery <TableUserRole>().Where(partitionKeyQuery);
TableQuerySegment <TableUserRole> querySegment = null;
while (querySegment == null || querySegment.ContinuationToken != null)
{
querySegment = await _rolesTable.ExecuteQuerySegmentedAsync(query, querySegment != null?querySegment.ContinuationToken : null);
roles.AddRange(querySegment.Results);
}
TableBatchOperation batch = new TableBatchOperation();
foreach (TableUserRole role in roles)
{
role.ETag = "*"; //Delete even if it has changed
batch.Add(TableOperation.Delete(role));
if (batch.Count >= 100)
{
try
{
//Try executing as a batch
await _rolesTable.ExecuteBatchAsync(batch);
batch.Clear();
}
catch { }
//If a batch wont work, try individually
foreach (TableOperation op in batch)
{
try
{
await _rolesTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
batch.Clear();
}
}
if (batch.Count > 0)
{
try
{
//Try executing as a batch
await _rolesTable.ExecuteBatchAsync(batch);
batch.Clear();
}
catch { }
//If a batch wont work, try individually
foreach (TableOperation op in batch)
{
try
{
await _rolesTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
}
if (error)
{
throw new Exception();
}
}
public async Task RemoveAllLoginsAsync(T user)
{
bool error = false;
List <TableUserLogin> Logins = new List <TableUserLogin>();
string partitionKeyQuery = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, user.Id);
TableQuery <TableUserLogin> query = new TableQuery <TableUserLogin>().Where(partitionKeyQuery);
TableQuerySegment <TableUserLogin> querySegment = null;
while (querySegment == null || querySegment.ContinuationToken != null)
{
querySegment = await _loginTable.ExecuteQuerySegmentedAsync(query, querySegment != null?querySegment.ContinuationToken : null);
Logins.AddRange(querySegment.Results);
}
TableBatchOperation batch = new TableBatchOperation();
TableBatchOperation batchIndex = new TableBatchOperation();
foreach (TableUserLogin login in Logins)
{
login.ETag = "*"; //Delete even if it has changed
batch.Add(TableOperation.Delete(login));
TableUserLoginProviderKeyIndex providerKeyIndex = new TableUserLoginProviderKeyIndex(user.Id, login.ProviderKey, login.LoginProvider);
providerKeyIndex.ETag = "*";
batchIndex.Add(TableOperation.Delete(providerKeyIndex));
if (batch.Count >= 100 || batchIndex.Count >= 100)
{
try
{
//Try executing as a batch
await _loginTable.ExecuteBatchAsync(batch);
batch.Clear();
}
catch { }
//If a batch wont work, try individually
foreach (TableOperation op in batch)
{
try
{
await _loginTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
//Delete the index individually becase of the partition keys
foreach (TableOperation op in batchIndex)
{
try
{
await _loginProviderKeyIndexTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
batch.Clear();
batchIndex.Clear();
}
}
if (batch.Count > 0 || batchIndex.Count > 0)
{
try
{
//Try executing as a batch
await _loginTable.ExecuteBatchAsync(batch);
batch.Clear();
}
// ReSharper disable once EmptyGeneralCatchClause
catch { }
//If a batch wont work, try individually
foreach (TableOperation op in batch)
{
try
{
await _loginTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
//Delete the index individually becase of the partition keys
foreach (TableOperation op in batchIndex)
{
try
{
await _loginProviderKeyIndexTable.ExecuteAsync(op);
}
catch
{
error = true;
}
}
}
if (error)
{
throw new Exception();
}
}
public static async Task <String> updateUser(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "update-User/{act}/{name}")] HttpRequestMessage request,
[Table("Users")] CloudTable cloudTable,
string name,
string act,
ILogger log)
{
Console.Out.WriteLine("in updateUser");
//addition
CloudTable table = null;
CloudTableClient client = null;
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
client = account.CreateCloudTableClient();
table = client.GetTableReference("Table00" + name);
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
if (act.Equals("remove"))
{
Console.Out.WriteLine("in remove");
//delete table
await table.DeleteIfExistsAsync();
//delete user from Users
TableOperation retrieve = TableOperation.Retrieve <TableEntity>(name, "");
CloudTable usersTable = client.GetTableReference("Users");
await usersTable.CreateIfNotExistsAsync();
TableResult result = await usersTable.ExecuteAsync(retrieve);
var deleteEntity = (TableEntity)result.Result;
TableOperation delete = TableOperation.Delete(deleteEntity);
await usersTable.ExecuteAsync(delete);
//delete requests
CloudTable requestTable = client.GetTableReference("Requests");
TableQuery <Request> idQuery = new TableQuery <Request>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, name));
TableQuerySegment <Request> queryResult = await requestTable.ExecuteQuerySegmentedAsync(idQuery, null);
var batchOperation = new TableBatchOperation();
foreach (var e in queryResult.Results)
{
batchOperation.Delete((TableEntity)e);
}
if ((queryResult.Results).Count != 0)
{
await requestTable.ExecuteBatchAsync(batchOperation);
}
return(act + " " + name);
}
else if (act == "add")
{
Console.Out.WriteLine("in add");
await table.CreateIfNotExistsAsync();
CloudTable usersTable = client.GetTableReference("Users");
await usersTable.CreateIfNotExistsAsync();
User newUser = new User();
newUser.PartitionKey = name;
newUser.RowKey = "";
newUser.Password = name;
newUser.UserType = "user";
TableOperation add = TableOperation.InsertOrReplace(newUser);
await usersTable.ExecuteAsync(add);
return(act + " " + name);
}
return(act + " " + name + " error in action");
}
static Task <IEnumerable <DynamicTableEntity> > GetAllAsync(CloudTable table,
TableQuery query) =>
table.ExecuteQuerySegmentedAsync(query, default)
.Bind(segment => segment.GetAllAsync(table, query));
public static async Task <status> GetIfIsOpen(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "get-isOpen/{id}/{state}")] HttpRequestMessage request,
string id,
string state,
[SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
log.LogInformation("Getting if to open or not.");
//addition
CloudTable table = null;
CloudTableClient client = null;
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
client = account.CreateCloudTableClient();
table = client.GetTableReference("Users");
await table.CreateIfNotExistsAsync();
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
status st = new status();
CloudTable garageTable = client.GetTableReference("Garage");
Boolean isInTheGarage = await isIdInTable(garageTable, "PartitionKey", id);
/*get the avaliable places*/
TableQuery <availablePlaces> idQuery = new TableQuery <availablePlaces>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "places"));
TableQuerySegment <availablePlaces> queryResult = await garageTable.ExecuteQuerySegmentedAsync(idQuery, null);
availablePlaces places = queryResult.FirstOrDefault();
if (isInTheGarage && state.Equals("in"))
{
st.isOpen = "arleady in the Garage!";
return(st);
}
else if (!isInTheGarage && state.Equals("out"))
{
st.isOpen = "arleady out of the Garage!";
return(st);
}
else if (isInTheGarage && state.Equals("out"))
{
//remove car from garage
TableOperation retrieve = TableOperation.Retrieve <Request>(id, "car");
TableResult result = await garageTable.ExecuteAsync(retrieve);
var deleteEntity = (TableEntity)result.Result;
TableOperation delete = TableOperation.Delete(deleteEntity);
await garageTable.ExecuteAsync(delete);
st.isOpen = "open";
//add one to the avaliavle places
places.numOfPlaces = (int.Parse(places.numOfPlaces) + 1).ToString();
//signalR
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "placesUpdate",
Arguments = new [] { places.numOfPlaces }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "garageUpdate",
Arguments = new[] { (Object)id }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = ((Request)result.Result).UserName + "Notify",
Arguments = new[] { ((Request)result.Result).ownerName + " left the garage" }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "adminNotify",
Arguments = new[] { ((Request)result.Result).ownerName + " left the garage" }
});
TableOperation add = TableOperation.InsertOrReplace(places);
await garageTable.ExecuteAsync(add);
return(st);
}
//in
if (int.Parse(places.numOfPlaces) == 0)
{
st.isOpen = "don't open the Garage is FULL!";
return(st);
}
List <String> users = await GetUsersFromTable(table);
foreach (string regesterdUser in users)
{
CloudTable usersTable = client.GetTableReference("Table00" + regesterdUser);
await usersTable.CreateIfNotExistsAsync();
Boolean isIdRegestered = await isIdInTable(usersTable, "RowKey", id);
if (isIdRegestered)
{
//add to garage
Request newCar = new Request();
newCar.PartitionKey = id;
newCar.RowKey = "car";
newCar.ownerName = ownerName;
newCar.UserName = regesterdUser;
TableOperation add = TableOperation.InsertOrReplace(newCar);
await garageTable.ExecuteAsync(add);
st.isOpen = "open";
//update the avaliable places
places.numOfPlaces = (int.Parse(places.numOfPlaces) - 1).ToString();
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "placesUpdate",
Arguments = new[] { places.numOfPlaces }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "garageUpdate",
Arguments = new[] { (Object)id }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = regesterdUser + "Notify",
Arguments = new[] { ownerName + " entered the garage" }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "adminNotify",
Arguments = new[] { ownerName + " entered the garage" }
});
TableOperation addOrReplace = TableOperation.InsertOrReplace(places);
await garageTable.ExecuteAsync(addOrReplace);
return(st);
}
}
st.isOpen = "don't open";
return(st);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
[Table("blogposts", "AzureWebJobsStorage")] CloudTable table,
ILogger log)
{
try
{
// Int default value isn't null so it is assumed to be always included.
int skip = Convert.ToInt32(req.Query["skip"]);
int takeCount = Convert.ToInt32(req.Query["takecount"]);
req.Query.TryGetValue("filterstring", out var filterString);
List <string> selectColumns =
req.Query.TryGetValue("selectcolumns", out var selectColumnsString) ?
JsonConvert.DeserializeObject <List <string> >(selectColumnsString) :
new List <string>()
{
"PartitionKey"
};
TableContinuationToken token =
(req.Query.TryGetValue("newxtpartitionkey", out var nextPk) &&
req.Query.TryGetValue("nextrowkey", out var nextRk)) ?
new TableContinuationToken()
{
NextPartitionKey = nextPk,
NextRowKey = nextRk,
NextTableName = null,
TargetLocation = StorageLocation.Primary
} : null;
while (skip > 0)
{
TableQuerySegment <BlogPostEntity> r = await table.ExecuteQuerySegmentedAsync(
new TableQuery <BlogPostEntity>()
{
TakeCount = skip,
SelectColumns = new List <string>()
{
"PartitionKey"
}
},
token
);
skip -= r.Results.Count;
token = r.ContinuationToken;
}
TableQuerySegment <BlogPostEntity> result = await table.ExecuteQuerySegmentedAsync(
new TableQuery <BlogPostEntity>()
{
FilterString = filterString,
SelectColumns = selectColumns,
TakeCount = takeCount
},
token);
return(new OkObjectResult(new QueryBlogPostEntitiesResponse(token, result.Results)));
}
catch (Exception e)
{
log.LogError($"function QueryBlogPosts -- caught exception {e} {e.Message} {e.StackTrace}");
return(new InternalServerErrorResult());
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetProStatus/{myPublicKey}")] HttpRequest req,
string myPublicKey,
[Table("ProStatus")] CloudTable proTable,
ILogger log)
{
log.LogInformation($"C# HTTP trigger {nameof(GetProStatus)} function processed a request.");
var privateKey = Utils.ParseToken(req);
if (privateKey == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized)
{
Content = new StringContent("You are not authorized to make this request.")
}
}
;
if (string.IsNullOrWhiteSpace(myPublicKey))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Invalid data to process request")
});
}
ProStatus status = null;
try
{
var publicKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, myPublicKey);
var privateKeyFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, privateKey);
var rangeQuery = new TableQuery <ProStatusEntity>().Where(
TableQuery.CombineFilters(publicKeyFilter, TableOperators.And, privateKeyFilter));
var entity = (await proTable.ExecuteQuerySegmentedAsync(rangeQuery, null)).FirstOrDefault();
status = new ProStatus
{
IsPro = entity != null,
Receipt = entity?.Receipt ?? string.Empty
};
}
catch (Exception ex)
{
log.LogError($"Error {nameof(GetFriends)} - Error: " + ex.Message);
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
}
var json = JsonConvert.SerializeObject(status);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
});
}
}
public static async Task Run(
[TimerTrigger("0 0 */4 * * *", RunOnStartup = false)] TimerInfo timer,
[Table("AuditConfig")] CloudTable configTbl,
[Table("AuditStats")] CloudTable statsTbl,
[Table("ResourceTypes")] CloudTable resourceTypesTbl,
[Queue("resources-to-tag")] ICollector <string> outQueue,
TraceWriter log)
{
_log = log;
_resourceTypesTbl = resourceTypesTbl;
log.Info("Starding subscription audit.");
var resourceTypesQuery = await resourceTypesTbl.ExecuteQuerySegmentedAsync(new TableQuery <ResourceType>(), null);
_resourceTypes = resourceTypesQuery.Results;
var auditConfigQuery = await configTbl.ExecuteQuerySegmentedAsync(new TableQuery <AuditConfig>(), null);
// Init config table if new deployment
if (auditConfigQuery.Results.Count == 0)
{
AuditConfig initConfig = new AuditConfig {
SubscriptionId = "enter_valid_subscription_id", RowKey = Guid.NewGuid().ToString(), RequiredTags = "comma,separated,tag,list,here", PartitionKey = "init"
};
TableOperation insertOperation = TableOperation.InsertOrReplace(initConfig);
await configTbl.ExecuteAsync(insertOperation);
log.Info("First run for new deployment. Please populate the AuditConfig table.");
return;
}
foreach (var auditConfig in auditConfigQuery.Results)
{
try
{
AuditStats stats = new AuditStats {
JobStart = DateTime.Now, PartitionKey = auditConfig.SubscriptionId, RowKey = Guid.NewGuid().ToString()
};
IEnumerable <string> requiredTagsList = auditConfig.RequiredTags.Split(',');
try
{
string token = AuthenticationService.GetAccessTokenAsync();
_resourceManager = new ResourceManagerService(token);
}
catch (Exception ex)
{
log.Error("Unable to connect to the ARM API, Message: " + ex.Message);
}
List <ResourceItem> tagUpdates = await ProcessResourceGroups(requiredTagsList, auditConfig.SubscriptionId, stats);
foreach (ResourceItem resourceItem in tagUpdates)
{
string messageText = JsonConvert.SerializeObject(resourceItem);
_log.Info("Requesting tags for: " + resourceItem.Id);
outQueue.Add(messageText);
}
log.Info("Completed audit of subscription: " + auditConfig.SubscriptionId);
stats.JobEnd = DateTime.Now;
TableOperation insertOperation = TableOperation.InsertOrReplace(stats);
await statsTbl.ExecuteAsync(insertOperation);
}
catch (Exception ex)
{
log.Error("Failure processing resource groups for auditConfig: " + auditConfig.RowKey);
log.Error(ex.Message);
}
}
}
// Overload #1
public static Task <TableQuerySegment <DynamicTableEntity> > ExecuteQuerySegmentedAsync(this CloudTable tbl, TableQuery query, TableContinuationToken continuationToken, CancellationToken token)
{
return(tbl.ExecuteQuerySegmentedAsync(query, continuationToken, null, null, token));
}
private async Task <List <AssignmentLearnContentEntity> > GetAllAssignmentLearnContentEntities(CloudTable assignmentLearnContentTable, string assignmentId)
{
TableQuery <AssignmentLearnContentEntity> assignmentSelectedLearnContentQuery = new TableQuery <AssignmentLearnContentEntity>()
.Where(
TableQuery.GenerateFilterCondition(nameof(TableEntity.PartitionKey), QueryComparisons.Equal, assignmentId)
);
List <AssignmentLearnContentEntity> assignmentSelectedLearnContent = new List <AssignmentLearnContentEntity>();
TableContinuationToken continuationToken = new TableContinuationToken();
do
{
TableQuerySegment <AssignmentLearnContentEntity> querySegment = await assignmentLearnContentTable.ExecuteQuerySegmentedAsync(assignmentSelectedLearnContentQuery, continuationToken);
continuationToken = querySegment.ContinuationToken;
assignmentSelectedLearnContent.AddRange(querySegment.Results);
} while (continuationToken != null);
return(assignmentSelectedLearnContent);
}
public static void Main(string[] args)
{
if (!ValidateArgs(args))
{
return;
}
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false);
Configuration = builder.Build();
IdentityConfiguration sourceConfig = new IdentityConfiguration();
sourceConfig.TablePrefix = Configuration.GetSection("source:IdentityConfiguration:TablePrefix")?.Value;
sourceConfig.StorageConnectionString = Configuration.GetSection("source:IdentityConfiguration:StorageConnectionString")?.Value;
sourceConfig.LocationMode = Configuration.GetSection("source:IdentityConfiguration:LocationMode")?.Value ?? string.Empty;
sourceConfig.UserTableName = Configuration.GetSection("source:IdentityConfiguration:UserTableName")?.Value ?? string.Empty;
sourceConfig.IndexTableName = Configuration.GetSection("source:IdentityConfiguration:IndexTableName")?.Value ?? string.Empty;
sourceConfig.RoleTableName = Configuration.GetSection("source:IdentityConfiguration:RoleTableName")?.Value ?? string.Empty;
IdentityConfiguration targetConfig = new IdentityConfiguration();
targetConfig.TablePrefix = Configuration.GetSection("target:IdentityConfiguration:TablePrefix")?.Value;
targetConfig.StorageConnectionString = Configuration.GetSection("target:IdentityConfiguration:StorageConnectionString")?.Value;
targetConfig.LocationMode = Configuration.GetSection("target:IdentityConfiguration:LocationMode")?.Value ?? string.Empty;
targetConfig.UserTableName = Configuration.GetSection("target:IdentityConfiguration:UserTableName")?.Value ?? string.Empty;
targetConfig.IndexTableName = Configuration.GetSection("target:IdentityConfiguration:IndexTableName")?.Value ?? string.Empty;
targetConfig.RoleTableName = Configuration.GetSection("target:IdentityConfiguration:RoleTableName")?.Value ?? string.Empty;
Console.WriteLine("MaxDegreeOfParallelism: {0}", iMaxdegreesparallel);
Console.WriteLine("PageSize: {0}", iPageSize);
Console.WriteLine("MigrateCommand: {0}", MigrateCommand);
var migration = MigrationFactory.CreateMigration(MigrateCommand);
using (IdentityCloudContext targetContext = new IdentityCloudContext(targetConfig))
{
Task.WhenAll(targetContext.IndexTable.CreateIfNotExistsAsync(),
targetContext.UserTable.CreateIfNotExistsAsync(),
targetContext.RoleTable.CreateIfNotExistsAsync()).Wait();
Console.WriteLine($"Target IndexTable: {targetContext.IndexTable.Name}");
Console.WriteLine($"Target UserTable: {targetContext.UserTable.Name}");
Console.WriteLine($"Target RoleTable: {targetContext.RoleTable.Name}");
string entityRecordName = "Users";
using (IdentityCloudContext sourceContext = new IdentityCloudContext(sourceConfig))
{
Console.WriteLine($"Source IndexTable: {sourceContext.IndexTable.Name}");
Console.WriteLine($"Source UserTable: {sourceContext.UserTable.Name}");
Console.WriteLine($"Source RoleTable: {sourceContext.RoleTable.Name}");
DateTime startLoad = DateTime.UtcNow;
var allDataList = new List <DynamicTableEntity>(iPageSize);
TableQuery tq = migration.GetSourceTableQuery();
tq.TakeCount = iPageSize;
TableContinuationToken continueToken = new TableContinuationToken();
int iSkippedUserCount = 0;
int iSkippedPageCount = 0;
int iPageCounter = 0;
while (continueToken != null)
{
DateTime batchStart = DateTime.UtcNow;
CloudTable sourceTable = sourceContext.UserTable;
if (MigrateCommand == MigrationFactory.Roles)
{
sourceTable = sourceContext.RoleTable;
entityRecordName = "Role and Role Claims";
}
var sourceResults = sourceTable.ExecuteQuerySegmentedAsync(tq, continueToken).Result;
continueToken = sourceResults.ContinuationToken;
int batchCount = sourceResults.Count(migration.UserWhereFilter);
iUserTotal += batchCount;
iPageCounter++;
bool includePage = (iStartPage == -1 || iPageCounter >= iStartPage) && (iFinishPage == -1 || iPageCounter <= iFinishPage);
if (includePage)
{
if (migrateOption)
{
migration.ProcessMigrate(targetContext, sourceContext, sourceResults.Results, iMaxdegreesparallel,
() =>
{
Interlocked.Increment(ref iUserSuccessConvert);
Console.WriteLine($"{entityRecordName}(s) Complete: {iUserSuccessConvert}");
},
(exMessage) =>
{
if (!string.IsNullOrWhiteSpace(exMessage))
{
userIdFailures.Add(exMessage);
}
Interlocked.Increment(ref iUserFailureConvert);
});
}
}
else
{
iSkippedPageCount++;
iSkippedUserCount += batchCount;
}
Console.WriteLine("Page: {2}{3}, {4} Batch: {1}: {0} seconds", (DateTime.UtcNow - batchStart).TotalSeconds, batchCount, iPageCounter, includePage ? string.Empty : "(Skipped)", entityRecordName);
//Are we done yet?
if (iFinishPage > 0 && iPageCounter >= iFinishPage)
{
break;
}
}
Console.WriteLine("");
Console.WriteLine("Elapsed time: {0} seconds", (DateTime.UtcNow - startLoad).TotalSeconds);
Console.WriteLine("Total {2} Skipped: {0}, Total Pages: {1}", iSkippedUserCount, iSkippedPageCount, entityRecordName);
Console.WriteLine("Total {2} To Convert: {0}, Total Pages: {1}", iUserTotal - iSkippedUserCount, iPageCounter - iSkippedPageCount, entityRecordName);
Console.WriteLine("");
if (migrateOption)
{
Console.WriteLine("Total {1} Successfully Converted: {0}", iUserSuccessConvert, entityRecordName);
Console.WriteLine("Total {1} Failed to Convert: {0}", iUserFailureConvert, entityRecordName);
if (iUserFailureConvert > 0)
{
Console.WriteLine($"{entityRecordName} Ids Failed:");
foreach (string s in userIdFailures)
{
Console.WriteLine(s);
}
}
}
}
}
DisplayAnyKeyToExit();
}
private List <KeyPhraseCount> GetRecordKeyPhrasesForRecordAssociations(KeyPhraseFilter oFilter)
{
List <KeyPhraseCount> keyPhrases = new List <KeyPhraseCount>();
CloudTable tRecordAssociationKeyphrases = Utils.GetCloudTable("stlprecordassociationkeyphrases", _logger);
// Create a default query
TableQuery <RecordKeyPhraseEntity> query = new TableQuery <RecordKeyPhraseEntity>();
//string finalFilter = "";
string recordFilter = "";
//string recordAssociationFilter = "";
string keyphraseFilter = "";
string combinedFilter = "";
// Add any record association filters
if (oFilter.records.Count > 0)
{
foreach (string rif in oFilter.records)
{
if (rif != null && rif != "")
{
// Validate the record filter
string cleanFilterPKey = Utils.CleanTableKey(rif);
if (!cleanFilterPKey.EndsWith("|"))
{
cleanFilterPKey = cleanFilterPKey + "|";
}
string pkqueryStart = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThanOrEqual, cleanFilterPKey);
string pkqueryEnd = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.LessThan, Utils.GetLessThanFilter(cleanFilterPKey));
string combinedRecordFilter = TableQuery.CombineFilters(pkqueryStart, TableOperators.And, pkqueryEnd);
if (recordFilter != "")
{
recordFilter = TableQuery.CombineFilters(recordFilter, TableOperators.Or, combinedRecordFilter);
}
else
{
recordFilter = combinedRecordFilter;
}
}
}
}
// Add any keyphrase filters
if (oFilter.keyphrases.Count > 0)
{
foreach (string rif in oFilter.keyphrases)
{
string cleanFilterRKey = Utils.CleanTableKey(rif);
string rkqueryStart = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, cleanFilterRKey);
string rkqueryEnd = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThan, Utils.GetLessThanFilter(cleanFilterRKey));
string rkqueryCombined = TableQuery.CombineFilters(rkqueryStart, TableOperators.And, rkqueryEnd);
if (keyphraseFilter != "")
{
keyphraseFilter = TableQuery.CombineFilters(keyphraseFilter, TableOperators.Or, rkqueryCombined);
}
else
{
keyphraseFilter = rkqueryCombined;
}
}
}
// Combine querys if needed
if (recordFilter.Length > 0)
{
if (keyphraseFilter.Length > 0)
{
// Combine queries when both filters are set
combinedFilter = TableQuery.CombineFilters(recordFilter, TableOperators.And, keyphraseFilter);
}
else
{
combinedFilter = recordFilter;
}
}
else
{
if (keyphraseFilter.Length > 0)
{
combinedFilter = keyphraseFilter;
}
}
// Create final combined query
query = new TableQuery <RecordKeyPhraseEntity>().Where(combinedFilter);
List <RecordKeyPhraseEntity> keyphraseEntities = new List <RecordKeyPhraseEntity>();
TableContinuationToken token = null;
var runningQuery = new TableQuery <RecordKeyPhraseEntity>()
{
FilterString = query.FilterString,
SelectColumns = query.SelectColumns
};
do
{
runningQuery.TakeCount = query.TakeCount - keyphraseEntities.Count;
Task <TableQuerySegment <RecordKeyPhraseEntity> > tSeg = tRecordAssociationKeyphrases.ExecuteQuerySegmentedAsync <RecordKeyPhraseEntity>(runningQuery, token);
tSeg.Wait();
token = tSeg.Result.ContinuationToken;
keyphraseEntities.AddRange(tSeg.Result);
} while (token != null && (query.TakeCount == null || keyphraseEntities.Count < query.TakeCount.Value) && keyphraseEntities.Count < 20000); //!ct.IsCancellationRequested &&
//keyphraseEntities.Sort((x, y) => String.Compare(x.RowKey, y.RowKey));
// Return only distinct keyphrases
foreach (RecordKeyPhraseEntity kp in keyphraseEntities)
{
KeyPhraseCount foundKPCount = keyPhrases.Find(x => (x.KeyPhrase == kp.RowKey));
if (foundKPCount == null)
{
KeyPhraseCount newKPCount = new KeyPhraseCount(kp.RowKey, 1);
keyPhrases.Add(newKPCount);
}
else
{
// Increment the number of keyphrases found
foundKPCount.Count++;
}
}
// Sort by most common keyphrase in descending order
keyPhrases.Sort((x, y) => y.Count.CompareTo(x.Count));
return(keyPhrases);
}
