protected async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
try
{
Console.WriteLine("Getting Items...");
TableQuery <TenantModel> query = new TableQuery <TenantModel>();
query.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForBool("IsIotHubDeployed", QueryComparisons.Equal, false),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThan, DateTime.Now.AddHours(-1))));
var items = await this.tableStorageClient.QueryAsync("tenant", query, stoppingToken);
foreach (var item in items)
{
Console.WriteLine($"Processing {item.TenantId}");
try
{
await this.blobStorageClient.CreateBlobContainerIfNotExistsAsync(item.TenantId + "-iot-file-upload");
Console.WriteLine("File Upload Container Made");
IotHubDescription iothub = await this.azureManagementClient.IotHubManagementClient.RetrieveAsync(item.IotHubName, stoppingToken);
if (iothub.Properties.State == "Active")
{
Console.WriteLine("IoT Hub found");
var connectionString = this.azureManagementClient.IotHubManagementClient.GetConnectionString(iothub.Name);
await this.appConfigurationClient.SetValueAsync($"tenant:{item.TenantId}:iotHubConnectionString", connectionString);
Assembly assembly = Assembly.GetExecutingAssembly();
StreamReader reader = new StreamReader(assembly.GetManifestResourceStream("dps.json"));
string template = await reader.ReadToEndAsync();
template = string.Format(
template,
item.DpsName,
this.config.Global.Location,
connectionString);
await this.azureManagementClient.DeployTemplateAsync(template);
item.IsIotHubDeployed = true;
await this.tableStorageClient.InsertOrReplaceAsync <TenantModel>("tenant", item);
}
}
catch (Microsoft.Azure.Management.IotHub.Models.ErrorDetailsException e)
{
if (e.Message == "Operation returned an invalid status code 'NotFound'")
{
Console.WriteLine("This is where we deploy IoT Hub");
Assembly assembly = Assembly.GetExecutingAssembly();
StreamReader reader = new StreamReader(assembly.GetManifestResourceStream("iothub.json"));
string template = await reader.ReadToEndAsync();
template = string.Format(
template,
item.IotHubName,
this.config.Global.Location,
this.config.Global.SubscriptionId,
this.config.Global.ResourceGroup,
item.TenantId,
"$twin.properties.desired.batchedTelemetry",
this.config.TenantManagerService.TelemetryEventHubConnectionString,
this.config.TenantManagerService.TwinChangeEventHubConnectionString,
this.config.TenantManagerService.LifecycleEventHubConnectionString,
this.config.Global.StorageAccountConnectionString);
await this.azureManagementClient.DeployTemplateAsync(template);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Error:");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
finally
{
await Task.Delay(15000, stoppingToken);
}
}
}
public virtual async Task <TenantListModel> GetAllActiveTenantAsync()
{
try
{
// Load the tenant from table storage
TableQuery <TenantModel> query = new TableQuery <TenantModel>().Where(TableQuery.GenerateFilterConditionForBool("IsIotHubDeployed", QueryComparisons.Equal, true));
List <TenantModel> result = await this.TableStorageClient.QueryAsync <TenantModel>(this.TenantTableId, query);
return(new TenantListModel(result));
}
catch (Exception e)
{
throw new Exception("Unable to retrieve the active tenants from table storage", e);
}
}
public Task <IEnumerable <T> > QueryRowsAsync <T>(string column, bool value) where T : new() => QueryRowsAsync <T>(TableQuery.GenerateFilterConditionForBool(column, QueryComparisons.Equal, value));
private static string GetAddressPrefix(CloudTableClient tableClient, TraceWriter log)
{
try
{
log.Info(string.Format("Retrieving available address prefix"));
CloudTable table = tableClient.GetTableReference("tblAddressPrefix");
TableQuery <AddressPrefixEntity> tableQuery = new TableQuery <AddressPrefixEntity>().Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "AddressPrefix"),
TableOperators.And,
TableQuery.GenerateFilterConditionForBool("Assigned", QueryComparisons.Equal, false))).Take(1);
AddressPrefixEntity entity = table.ExecuteQuery(tableQuery).FirstOrDefault();
if (entity != null && !entity.Assigned)
{
entity.Assigned = true;
TableOperation updateOperation = TableOperation.Replace(entity);
table.Execute(updateOperation);
log.Info(string.Format("Assigned address prefix: {0}", entity.IPAddress));
return(entity.IPAddress);
}
else
{
log.Error(string.Format("No available address prefixes found"));
return(null);
}
}
catch (System.Exception e)
{
log.Error(string.Format("Could not retrieve a address prefix. Exception:{0}", e.Message));
return(null);
}
}
public static string PropertyEqual(this string property, bool value)
{
return(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, value));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "hello")]
HttpRequestMessage req,
TraceWriter log
)
{
log.Info($"<<<<: {await req.Content.ReadAsStringAsync()}");
HelloRequest command;
try
{
command = await req.Content.ReadAsAsync <HelloRequest>();
}
catch (Exception ex)
{
return(req.CreateResponse(new Result {
ErrorCode = ErrorCode.BadRequest, ErrorMessage = ex.Message
}));
}
if (command?.HostID == null)
{
return(req.CreateResponse <Result>(ErrorCode.MissingHostID));
}
if (string.IsNullOrEmpty(command.HostID.Hostname))
{
return(req.CreateResponse <Result>(ErrorCode.MissingHostname));
}
if (string.IsNullOrEmpty(command.HostID.SerialNumber))
{
return(req.CreateResponse <Result>(ErrorCode.MissingSerialNumber));
}
log.Info($"HostID: {command.HostID.Hostname}, {command.HostID.SerialNumber}");
var table = await Storage.Table;
var result = await table.ExecuteAsync(TableOperation.Retrieve <RaspberryPiEntity>("pi", command.HostID.SerialNumber));
if (result.HttpStatusCode == 404)
{
result = await table.ExecuteAsync(
TableOperation.Insert(
new RaspberryPiEntity(command.HostID.SerialNumber)
{
Id = Guid.NewGuid(), // once
Hostname = command.HostID.Hostname,
Version = command.Version,
}
)
);
}
else
{
var result2 = await table.ExecuteAsync(
TableOperation.Merge(
new RaspberryPiEntity(command.HostID.SerialNumber)
{
ETag = result.Etag,
Hostname = command.HostID.Hostname,
Version = command.Version,
}
)
);
// patch retrieve op
((RaspberryPiEntity)result.Result).Hostname = command.HostID.Hostname;
((RaspberryPiEntity)result.Result).Version = command.Version;
}
var pi = (RaspberryPiEntity)result.Result;
log.Info($"TV-ID: {pi.Id}");
var commandQueue = Storage.GetCommandQueueReference(pi.Id);
await commandQueue.CreateIfNotExistsAsync();
if (!string.IsNullOrEmpty(pi.Command))
{
try
{
await commandQueue.AddCommandAsync(new PuppeteerCommand { Commands = JArray.Parse(pi.Command) });
}
catch (Exception ex)
{
log.Error($"'{pi.Name}' has invalid hello command", ex);
}
}
else
{
if (!string.IsNullOrEmpty(pi.GotoUrl))
{
Uri gotoUrl;
if (Uri.TryCreate(pi.GotoUrl, UriKind.Absolute, out gotoUrl))
{
await commandQueue.AddCommandAsync(new GotoCommand { Url = gotoUrl });
}
else
{
log.Error($"'{pi.Name}' has invalid goto URL");
}
}
}
var jobsSegment = await table.ExecuteQuerySegmentedAsync(new TableQuery <JobEntity>
{
FilterString = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(nameof(JobEntity.PartitionKey), QueryComparisons.Equal, JobEntity.Prefix),
TableOperators.And,
TableQuery.GenerateFilterConditionForBool(nameof(JobEntity.Enabled), QueryComparisons.Equal, true)
)
}, null);
var jobs = new List <HelloJobResponse>();
foreach (var job in jobsSegment.Results)
{
JObject jobCommand;
try
{
jobCommand = JObject.Parse(job.Command);
}
catch (Exception ex)
{
log.Error($"job '{job.Name}' has invalid payload. this job will not be run", ex);
continue;
}
jobs.Add(new HelloJobResponse
{
Name = job.Name,
ETag = job.ETag,
CronExpression = job.CronExpression,
Command = jobCommand,
TimeZone = job.TimeZone
});
}
return(req.CreateResponse <Result <HelloResponse> >(new HelloResponse
{
Id = pi.Id,
Name = pi.Name,
GetCommandUrl = new Uri(req.RequestUri, $"/api/tv/{pi.Id}/commands/-/get"),
EventsUrl = new Uri(req.RequestUri, $"/api/tv/{pi.Id}/events"),
Jobs = jobs
}));
}
T ISagaPersister.Get <T>(string property, object value)
{
var type = typeof(T);
var tableName = type.Name;
var table = client.GetTableReference(tableName);
TableQuery <DictionaryTableEntity> query;
var propertyInfo = type.GetProperty(property);
if (propertyInfo.PropertyType == typeof(byte[]))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value));
}
else if (propertyInfo.PropertyType == typeof(bool))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value));
}
else if (propertyInfo.PropertyType == typeof(DateTime))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value));
}
else if (propertyInfo.PropertyType == typeof(Guid))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value));
}
else if (propertyInfo.PropertyType == typeof(Int32))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value));
}
else if (propertyInfo.PropertyType == typeof(Int64))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value));
}
else if (propertyInfo.PropertyType == typeof(Double))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value));
}
else if (propertyInfo.PropertyType == typeof(string))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value));
}
else
{
throw new NotSupportedException(
string.Format("The property type '{0}' is not supported in windows azure table storage",
propertyInfo.PropertyType.Name));
}
try
{
return(ToEntity <T>(table.ExecuteQuery(query).FirstOrDefault()));
}
catch (WebException ex)
{
// occurs when table has not yet been created, but already looking for absence of instance
if (ex.Status == WebExceptionStatus.ProtocolError && ex.Response != null)
{
var response = (HttpWebResponse)ex.Response;
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(default(T));
}
}
throw;
}
}
protected async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
// Get the list of tenants
TableQuery <TenantMigrationModel> query = new TableQuery <TenantMigrationModel>().Where(TableQuery.GenerateFilterConditionForBool("IsIotHubDeployed", QueryComparisons.Equal, true));
List <TenantMigrationModel> tenants = await this.tableStorageClient.QueryAsync <TenantMigrationModel>(TenantTable, query);
// Verify against the list of processed tenants
TableQuery <TenantMigrationModel> processedTenantsQuery = new TableQuery <TenantMigrationModel>().Where(TableQuery.GenerateFilterConditionForBool(nameof(TenantMigrationModel.IsMigrationCompleted), QueryComparisons.Equal, true));
List <TenantMigrationModel> processedTenants = await this.tableStorageClient.QueryAsync <TenantMigrationModel>(TenantMigrationStatus, processedTenantsQuery);
var tenantsToMigrate = tenants.Select(t => t.TenantId).Except(processedTenants.Select(t => t.TenantId));
if (tenantsToMigrate != null && tenantsToMigrate.Count() > 0)
{
string tenantToMigrate = tenantsToMigrate.First();
// Get Deployments for Name
Dictionary <string, string> deployments = await this.GetDeployments(tenantToMigrate, "deployments");
bool isTenantMigrationCompleted = false;
while (!isTenantMigrationCompleted)
{
// get the data from tenant for deploymentdevices collection
IEnumerable <ValueServiceModel> deploymentImpactedDevicesData = await this.GetDataForMigration(tenantToMigrate, DeploymentDevicePropertiesCollection);
if (deploymentImpactedDevicesData != null && deploymentImpactedDevicesData.Count() > 0)
{
// Convert the data into new model to be saved
foreach (ValueServiceModel data in deploymentImpactedDevicesData)
{
DeploymentHistoryModel deviceDeploymentHistory = new DeploymentHistoryModel();
deviceDeploymentHistory.DeploymentId = data.CollectionId.Substring(18);
deviceDeploymentHistory.DeviceId = data.Key;
deviceDeploymentHistory.DeploymentName = deployments.ContainsKey(deviceDeploymentHistory.DeploymentId) ? deployments[deviceDeploymentHistory.DeploymentId] : string.Empty;
deviceDeploymentHistory.LastUpdatedDateTimeUtc = data.Timestamp.UtcDateTime;
deviceDeploymentHistory.PreviousFirmwareTwin = null;
deviceDeploymentHistory.Twin = JsonConvert.DeserializeObject <TwinServiceModel>(data.Data);
// save the record to new collection
var isSuccess = await this.SaveDataToStorage(string.Format(DeviceDeploymentHistory, deviceDeploymentHistory.DeviceId), deviceDeploymentHistory.DeploymentId, deviceDeploymentHistory, tenantToMigrate);
if (isSuccess)
{
// Delete the existing data once saved.
await this.DeleteDataFromStorage(tenantToMigrate, data.CollectionId, data.Key);
}
}
}
else
{
IEnumerable <ValueServiceModel> deploymentImpactedDevicesHistoryData = await this.GetDataForMigration(tenantToMigrate, DeploymentHistoryPropertiesCollection);
if (deploymentImpactedDevicesHistoryData != null && deploymentImpactedDevicesHistoryData.Count() > 0)
{
// Convert the data into new model to be saved
foreach (ValueServiceModel data in deploymentImpactedDevicesData)
{
DeploymentHistoryModel deviceDeploymentHistory = new DeploymentHistoryModel();
deviceDeploymentHistory.DeploymentId = data.CollectionId.Substring(18, data.CollectionId.Length - (36 + 1) - 18);
deviceDeploymentHistory.DeviceId = data.Key;
deviceDeploymentHistory.DeploymentName = deployments.ContainsKey(deviceDeploymentHistory.DeploymentId) ? deployments[deviceDeploymentHistory.DeploymentId] : string.Empty;
deviceDeploymentHistory.LastUpdatedDateTimeUtc = data.Timestamp.UtcDateTime;
deviceDeploymentHistory.PreviousFirmwareTwin = null;
deviceDeploymentHistory.Twin = JsonConvert.DeserializeObject <TwinServiceModel>(data.Data);
// save the record to new collection
var isSuccess = await this.SaveDataToStorage(string.Format(DeviceDeploymentHistory, deviceDeploymentHistory.DeviceId), deviceDeploymentHistory.DeploymentId, deviceDeploymentHistory, tenantToMigrate);
if (isSuccess)
{
// Delete the existing data once saved.
await this.DeleteDataFromStorage(tenantToMigrate, data.CollectionId, data.Key);
}
}
}
else
{
isTenantMigrationCompleted = true;
break;
}
}
await Task.Delay(30 * 1000, stoppingToken);
}
// Update the TenantMigrationStatus to true;
await this.InsertTenantMigrationStatus(tenantToMigrate);
}
await Task.Delay(300 * 1000, stoppingToken);
}
}
public void TableGenericQueryOnSupportedTypes()
{
// 1. Filter on String
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterCondition("String", QueryComparisons.GreaterThanOrEqual, "0050"), Midpoint);
// 2. Filter on Guid
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForGuid("Guid", QueryComparisons.Equal, this.middleRef.Guid), 1);
// 3. Filter on Long
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForLong("Int64", QueryComparisons.GreaterThanOrEqual,
this.middleRef.LongPrimitive), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForLong("LongPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.LongPrimitive), Midpoint);
// 4. Filter on Double
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Double), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForDouble("DoublePrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.DoublePrimitive), Midpoint);
// 5. Filter on Integer
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForInt("Int32", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Int32), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForInt("IntegerPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.IntegerPrimitive), Midpoint);
// 6. Filter on Date
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForDate("DateTimeOffset", QueryComparisons.GreaterThanOrEqual,
this.middleRef.DateTimeOffset), Midpoint);
// 7. Filter on Boolean
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, this.middleRef.Bool), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBool("BoolPrimitive", QueryComparisons.Equal, this.middleRef.BoolPrimitive),
Midpoint);
// 8. Filter on Binary
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.Equal, this.middleRef.Binary), 1);
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.Equal,
middleRef.BinaryPrimitive), 1);
// 9. Filter on Binary GTE
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Binary), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.BinaryPrimitive), Midpoint);
// 10. Complex Filter on Binary GTE
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
this.middleRef.PartitionKey),
TableOperators.And,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Binary)), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.BinaryPrimitive), Midpoint);
}
/// <summary>
/// Method to get a TimeOffMappingEntity by time off request id.
/// </summary>
/// <param name="timeOffRequestId">The TimeOffRequestId of the request to retrieve.</param>
/// <returns>A <see cref="TimeOffMappingEntity"/>.</returns>
public async Task <TimeOffMappingEntity> GetTimeOffRequestMappingEntityByRequestIdAsync(string timeOffRequestId)
{
await this.EnsureInitializedAsync().ConfigureAwait(false);
var getEntitiesProps = new Dictionary <string, string>()
{
{ "CurrentCallingAssembly", Assembly.GetCallingAssembly().GetName().Name },
};
this.telemetryClient.TrackTrace(MethodBase.GetCurrentMethod().Name, getEntitiesProps);
// Table query
TableQuery <TimeOffMappingEntity> query = new TableQuery <TimeOffMappingEntity>();
query.Where(TableQuery.CombineFilters(TableQuery.GenerateFilterCondition("ShiftsRequestId", QueryComparisons.Equal, timeOffRequestId), TableOperators.And, TableQuery.GenerateFilterConditionForBool("IsActive", QueryComparisons.Equal, true)));
// Results list
List <TimeOffMappingEntity> results = new List <TimeOffMappingEntity>();
TableContinuationToken continuationToken = null;
if (await this.timeoffEntityMappingTable.ExistsAsync().ConfigureAwait(false))
{
do
{
TableQuerySegment <TimeOffMappingEntity> queryResults = await this.timeoffEntityMappingTable.ExecuteQuerySegmentedAsync(query, continuationToken).ConfigureAwait(false);
continuationToken = queryResults.ContinuationToken;
results.AddRange(queryResults.Results);
}while (continuationToken != null);
}
return(results.FirstOrDefault(x => x.ShiftsRequestId == timeOffRequestId));
}
private string GenerateFilterCondition(DataTable schema, string columnName, string columnValue)
{
if (columnName.Equals(AZURE_TABLE_PARTITION_KEY_COL))
{
return(TableQuery.GenerateFilterCondition(columnName, QueryComparisons.GreaterThan, columnValue));
}
else if (columnName.Equals(AZURE_TABLE_ROW_KEY_COL))
{
return(TableQuery.GenerateFilterCondition(columnName, QueryComparisons.GreaterThan, columnValue));
}
else if (columnName.Equals(AZURE_TABLE_TIMESTAMP_COL))
{
return(TableQuery.GenerateFilterConditionForDate(columnName, QueryComparisons.GreaterThan, DateTimeOffset.Parse(columnValue)));
}
else if (!schema.Columns.Contains(columnName))
{
return(String.Empty);
}
else
{
Type type = schema.Columns[columnName].DataType;
if (type == typeof(Byte[]))
{
return(String.Empty);
}
else if (type == typeof(Boolean))
{
return(TableQuery.GenerateFilterConditionForBool(columnName, QueryComparisons.GreaterThan, Boolean.Parse(columnValue)));
}
else if (type == typeof(Int32))
{
return(TableQuery.GenerateFilterConditionForInt(columnName, QueryComparisons.GreaterThan, Int32.Parse(columnValue)));
}
else if (type == typeof(Int64))
{
return(TableQuery.GenerateFilterConditionForLong(columnName, QueryComparisons.GreaterThan, Int64.Parse(columnValue)));
}
else if (type == typeof(DateTime))
{
return(TableQuery.GenerateFilterConditionForDate(columnName, QueryComparisons.GreaterThan, DateTime.Parse(columnValue)));
}
else if (type == typeof(DateTimeOffset))
{
return(TableQuery.GenerateFilterConditionForDate(columnName, QueryComparisons.GreaterThan, DateTimeOffset.Parse(columnValue)));
}
else if (type == typeof(Double))
{
return(TableQuery.GenerateFilterConditionForDouble(columnName, QueryComparisons.GreaterThan, Double.Parse(columnValue)));
}
else if (type == typeof(Guid))
{
return(TableQuery.GenerateFilterConditionForGuid(columnName, QueryComparisons.GreaterThan, Guid.Parse(columnValue)));
}
else if (type == typeof(String))
{
return(TableQuery.GenerateFilterCondition(columnName, QueryComparisons.GreaterThan, columnValue));
}
else
{
return(String.Empty);
}
}
}
private string BuildFilerQuery()
{
string queryFilters = null;
foreach (var filter in Filters)
{
var fieldName = _entityDefinition.Filters().FirstOrDefault(f => f.Accesor.MemberPath == filter.EntityMember.MemberPath)?.Name;
if (String.IsNullOrWhiteSpace(fieldName))
{
throw new StorageArgumentOutOfRangeException(nameof(filter), $"Not found filter with signature {filter.EntityMember.MemberPath}");
}
string queryFilter = null;
var toCompare = filter.ConstantMember.Value;
switch (Type.GetTypeCode(toCompare.GetType()))
{
case TypeCode.Boolean:
queryFilter = TableQuery.GenerateFilterConditionForBool(fieldName, GetOperator(filter.Operator), (bool)toCompare);
break;
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
queryFilter = TableQuery.GenerateFilterConditionForInt(fieldName, GetOperator(filter.Operator), (int)toCompare);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
queryFilter = TableQuery.GenerateFilterConditionForLong(fieldName, GetOperator(filter.Operator), (long)toCompare);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.Decimal:
queryFilter = TableQuery.GenerateFilterConditionForDouble(fieldName, GetOperator(filter.Operator), (double)toCompare);
break;
case TypeCode.DateTime:
queryFilter = TableQuery.GenerateFilterConditionForDate(fieldName, GetOperator(filter.Operator), (DateTime)toCompare);
break;
case TypeCode.Char:
case TypeCode.String:
queryFilter = TableQuery.GenerateFilterCondition(fieldName, GetOperator(filter.Operator), toCompare.ToString());
break;
default:
throw new StorageArgumentOutOfRangeException(nameof(filter), $"Can not extract value for type '{toCompare.GetType().FullName}'");
}
if (String.IsNullOrWhiteSpace(queryFilters))
{
queryFilters = queryFilter;
}
else
{
queryFilters = TableQuery.CombineFilters(queryFilters, TableOperators.And, queryFilter);
}
}
return(queryFilters);
}
public async static Task <IHttpResponse> GetAllSecureAsync(
[Api.Meta.Flows.WorkflowParameter(Value = "{{AuthenticationMethod}}")]
[QueryParameter(Name = "method")]
IRef <Method> methodRef,
[OptionalQueryParameter(Name = "successOnly")] bool successOnly,
[Api.Meta.Flows.WorkflowParameter(Description = "ACP,Dash,TCM,HUDDLE", Value = "")]
[OptionalQueryParameter(Name = "search")]
string search,
[OptionalQueryParameter(Name = "months")] int?monthsMaybe,
AzureApplication application,
EastFive.Api.Security security,
IHttpRequest request,
[Api.Meta.Flows.WorkflowVariable(AuthorizationPropertyName, "authorization{0}")]
ContentTypeResponse <RedirectionManager[]> onContent,
UnauthorizedResponse onUnauthorized,
ConfigurationFailureResponse onConfigFailure,
BadRequestResponse onBadRequest)
{
// this query is faster than the version commented out below
var methodMaybe = await Method.ById(methodRef, application, (m) => m, () => default(Method?));
if (methodMaybe.IsDefault())
{
return(onBadRequest().AddReason("Method no longer supported"));
}
var method = methodMaybe.Value;
var months = monthsMaybe.HasValue ? Math.Abs(monthsMaybe.Value) : 1;
var since = DateTime.UtcNow.Date.AddMonths(-months);
var query = new TableQuery <GenericTableEntity>().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForGuid("method", QueryComparisons.Equal, method.id),
TableOperators.And,
TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, since),
TableOperators.And,
TableQuery.GenerateFilterConditionForBool("authorized", QueryComparisons.Equal, true)
)
)
);
var table = EastFive.Azure.Persistence.AppSettings.Storage.ConfigurationString(
(conn) =>
{
var account = CloudStorageAccount.Parse(conn);
var client = account.CreateCloudTableClient();
return(client.GetTableReference("authorization"));
},
(why) => throw new Exception(why));
var segment = default(TableQuerySegment <GenericTableEntity>);
var token = default(TableContinuationToken);
var redirections = new RedirectionManager[] { };
do
{
segment = await table.ExecuteQuerySegmentedAsync(query, token);
token = segment.ContinuationToken;
var result = await segment.Results
.Select(
async (entity) =>
{
var id = Guid.Parse(entity.RowKey);
var when = entity.Timestamp.DateTime;
var props = entity.WriteEntity(default);
public async Task <PvPGameModel[]> GetOpenGames()
{
var table = await this.GetGameTable();
TableQuery <PvPGameEntity> query = new TableQuery <PvPGameEntity>().Where(TableQuery.GenerateFilterConditionForBool("OpenForJoin", QueryComparisons.Equal, true));
var result = await table.ExecuteQueryAsync <PvPGameEntity>(query);
return(result.Select(o => new PvPGameModel()
{
GameName = o.GameName, Id = o.RowKey
}).ToArray());
}
private static async Task DealUserToAsset(long minAmount, long maxAmount, string yemUserProductAzureTableName, string writeAssetAzureTable, string writeYemUserProductAzureTable,
CloudTableClient tableClient, string yemUserPurchase, List <OnSellAssetDto> onSellAssetDtos)
{
CloudTable cloudPurchaseOrderTable = tableClient.GetTableReference(yemUserProductAzureTableName);
TableQuery <YemUserProductDto> queryPurchaseOrder;
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (maxAmount > 0)
{
//queryPurchaseOrder = new TableQuery<YemUserProductDto>()
// .Where($"PartitionKey eq '{yemUserPurchase}' and RemainingAmount ge {minAmount} and RemainingAmount lt {maxAmount} and IsLock eq false");
string startsWithCondition = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, yemUserPurchase),
TableOperators.And,
TableQuery.GenerateFilterConditionForLong("RemainingAmount", QueryComparisons.GreaterThanOrEqual, minAmount));
string filterCondition = TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForLong("RemainingAmount", QueryComparisons.LessThan, maxAmount),
TableOperators.And,
startsWithCondition
);
string endCondition = TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForBool("IsLock", QueryComparisons.Equal, false),
TableOperators.And,
filterCondition
);
queryPurchaseOrder = new TableQuery <YemUserProductDto>().Where(endCondition);
}
else
{
queryPurchaseOrder = new TableQuery <YemUserProductDto>()
.Where($"PartitionKey eq '{yemUserPurchase}' and RemainingAmount gt 0 and IsLock eq false");
}
var yemUserProductDtos = cloudPurchaseOrderTable.ExecuteQuery(queryPurchaseOrder).OrderByDescending(p => p.RemainingAmount).ToList();
yemUserProductDtos = yemUserProductDtos.Where(p => p.RemainingAmount > 0).ToList();
Console.WriteLine("要处理的购买订单条数=" + yemUserProductDtos.Count());
Console.WriteLine("待分配的资产数=" + onSellAssetDtos.Count());
List <OnSellAssetDto> oldOnSellAssetDtos = onSellAssetDtos;
if (!oldOnSellAssetDtos.Any())
{
Console.WriteLine("没有处理的资产");
return;
}
int index = 0;
//int syncIndex = 0; //备份索引
Stopwatch s = new Stopwatch();
s.Start();
List <OnSellAssetDto> lastOnSellAssetDtos = new List <OnSellAssetDto>(); //上一次的资产情况
foreach (var item in yemUserProductDtos)
{
if (!lastOnSellAssetDtos.Any()) //第一次
{
lastOnSellAssetDtos.AddRange(oldOnSellAssetDtos.MapToOnSellAssetList());
}
index++;
var addUserAssetRatios = new List <UserAssetRatio>(); //记录每笔购买产生的比例 用户资产关系
List <OnSellAssetDto> modifyOnSellAssets = new List <OnSellAssetDto>(); //记录每笔购买使用的资产
var addAssetUserRatios = new List <UserAssetRatio>(); //记录每笔购买产生的比例 资产用户关系
YemUserProductDto newYemUserProductDto = null;
Console.WriteLine("总共处理的条数为：" + yemUserProductDtos.Count + ",当前处理的条数：" + index);
Console.WriteLine("还需要处理的资产数=" + oldOnSellAssetDtos.Count());
long sumAssetCount = oldOnSellAssetDtos.Sum(p => p.RemainderTotal);
long waitingDealAmount = item.RemainingAmount; //购买订单待处理的金额
long currentDealPurchaseAmount = 0; //本次处理的金额
for (int i = oldOnSellAssetDtos.Count - 1; i >= 0; i--)
{
if (item.RemainingAmount == 0)
{
break;
}
var assetItem = oldOnSellAssetDtos[i];
long allocateAmount = AllocateAmountByAsset(waitingDealAmount, assetItem.RemainderTotal, sumAssetCount);
if (item.RemainingAmount < allocateAmount)
{
allocateAmount = item.RemainingAmount;
}
if (assetItem.RemainderTotal < allocateAmount)
{
allocateAmount = assetItem.RemainderTotal;
}
if (allocateAmount <= 0)
{
continue;
}
item.RemainingAmount -= allocateAmount;
currentDealPurchaseAmount += allocateAmount; //统计该订单分配的总金额
assetItem.RemainderTotal -= allocateAmount;
var userAssetRatioTuple = CreateUserAssetRatio(item, assetItem, allocateAmount); //第一个是用户资产关系 第二个是资产用户关系
addUserAssetRatios.Add(userAssetRatioTuple.Item1);
addAssetUserRatios.Add(userAssetRatioTuple.Item2);
var updateOnSellAsset = BuildOnSellAsset(assetItem, allocateAmount); //修改资产的信息
modifyOnSellAssets.Add(updateOnSellAsset);
if (assetItem.RemainderTotal == 0)
{
oldOnSellAssetDtos.Remove(assetItem);
}
}
newYemUserProductDto = BuildYemUserProduct(item, currentDealPurchaseAmount); //修改购买订单需要配置的参数
//保存数据库
await InsertOrReplaceAzureTable(tableClient, newYemUserProductDto, addUserAssetRatios, addAssetUserRatios,
modifyOnSellAssets, writeAssetAzureTable, writeYemUserProductAzureTable, currentDealPurchaseAmount, lastOnSellAssetDtos);
lastOnSellAssetDtos = new List <OnSellAssetDto>();
lastOnSellAssetDtos.AddRange(modifyOnSellAssets.MapToOnSellAssetList()); //记录上一次资产列表
if (!oldOnSellAssetDtos.Any())
{
Console.WriteLine("没有处理的资产");
break;
}
}
s.Stop();
Console.WriteLine("End:" + s.ElapsedMilliseconds);
}
public async Task UpdateStateAsync(string serviceName, string functionName)
{
var currentState = await _circuitBreakerStateService.GetStateAsync(serviceName, functionName);
if (currentState == null)
{
//We start by default with a closed state
await _circuitBreakerStateService.CloseCircuitAsync(serviceName, functionName);
currentState = CircuitBreakerState.Closed;
}
if (currentState.IsOpen)
{
//We do nothing here, the state should be updated via a timer
return;
}
var tableClient = _storageAccount.CreateCloudTableClient();
var configurationTableReference = tableClient.GetTableReference(TABLE_CONFIGURATION);
var configuration = (await configurationTableReference.ExecuteAsync(TableOperation.Retrieve <ConfigurationEntity>(serviceName, functionName))).Result as ConfigurationEntity;
var operationTableReference = tableClient.GetTableReference(TABLE_OPERATION);
if (currentState.IsClosed)
{
var timestampToCompareWith = DateTime.Now.AddMilliseconds(-configuration.FailureRequestThresholdMilliseconds);
if (currentState.Timestamp > timestampToCompareWith)
{
timestampToCompareWith = new DateTime(currentState.Timestamp.Ticks);
}
//Do we need to open the circuit ?
var operations = (await operationTableReference.ExecuteQuerySegmentedAsync(
new TableQuery <OperationEntity>().Where(
TableQuery.CombineFilters(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{serviceName}_{functionName}"),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThan, timestampToCompareWith
))), null)).Results;
if (operations.Count(o => !o.IsSuccess) >= configuration.FailureRequestThreshold)
{
//Yes we do
await _circuitBreakerStateService.OpenCircuitAsync(serviceName, functionName);
}
}
else
{
//Here, the circuit is half open. Do we need to close it ?
var failures = (await operationTableReference.ExecuteQuerySegmentedAsync(
new TableQuery <OperationEntity>().Where(
TableQuery.CombineFilters(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{serviceName}_{functionName}"),
TableOperators.And,
TableQuery.GenerateFilterConditionForBool("IsSuccess", QueryComparisons.Equal, false)
)), null)).Results;
//Since the latest failure, did we reach the threshold to close the circuit ?
var latestFailure = failures.OrderByDescending(o => o.Timestamp).FirstOrDefault();
var successSinceLatestFailure = (await operationTableReference.ExecuteQuerySegmentedAsync(
new TableQuery <OperationEntity>().Where(
TableQuery.CombineFilters(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{serviceName}_{functionName}"),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThan, latestFailure.Timestamp)
)), null)).Results.Where(r => r.IsSuccess);
if (successSinceLatestFailure == null || !successSinceLatestFailure.Any())
{
//If the latest is a failure, the circuit should be reopened
await _circuitBreakerStateService.OpenCircuitAsync(serviceName, functionName);
}
else if (successSinceLatestFailure.Count() >= configuration.HalfOpenSuccessThreshold)
{
//There we close it
await _circuitBreakerStateService.CloseCircuitAsync(serviceName, functionName);
}
}
}
private string GenerateSearchFilter(string searchText, bool includePrerelease, bool includeSemVer2)
{
var result = "";
if (!string.IsNullOrWhiteSpace(searchText))
{
// Filter to rows where the "searchText" prefix matches on the partition key.
var prefix = searchText?.TrimEnd().Split(separator: null).Last() ?? string.Empty;
var prefixLower = prefix;
var prefixUpper = prefix + "~";
var partitionLowerFilter = TableQuery.GenerateFilterCondition(
"PartitionKey",
QueryComparisons.GreaterThanOrEqual,
prefixLower);
var partitionUpperFilter = TableQuery.GenerateFilterCondition(
"PartitionKey",
QueryComparisons.LessThanOrEqual,
prefixUpper);
result = GenerateAnd(partitionLowerFilter, partitionUpperFilter);
}
// Filter to rows that are listed.
result = GenerateAnd(
result,
GenerateIsTrue(nameof(PackageEntity.Listed)));
if (!includePrerelease)
{
result = GenerateAnd(
result,
GenerateIsFalse(nameof(PackageEntity.IsPrerelease)));
}
if (!includeSemVer2)
{
result = GenerateAnd(
result,
TableQuery.GenerateFilterConditionForInt(
nameof(PackageEntity.SemVerLevel),
QueryComparisons.Equal,
0));
}
return(result);
string GenerateAnd(string left, string right)
{
if (string.IsNullOrEmpty(left))
{
return(right);
}
return(TableQuery.CombineFilters(left, TableOperators.And, right));
}
string GenerateIsTrue(string propertyName)
{
return(TableQuery.GenerateFilterConditionForBool(
propertyName,
QueryComparisons.Equal,
givenValue: true));
}
string GenerateIsFalse(string propertyName)
{
return(TableQuery.GenerateFilterConditionForBool(
propertyName,
QueryComparisons.Equal,
givenValue: false));
}
}
public async void Execute()
{
while (true)
{
IEnumerable <StillInterestedEntity> messages = null;
do
{
var day = DateTimeOffset.UtcNow.AddDays(-configurationProvider.GetConfiguration <int>("stillInterestedTimeoutDays"));
TableQuery <StillInterestedEntity> tableQuery = new TableQuery <StillInterestedEntity>().Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.LessThanOrEqual, day),
TableOperators.And, TableQuery.GenerateFilterConditionForBool("ReceivedAnswer", QueryComparisons.Equal, false)));
messages = await tableStorageProvider.RetrieveFromTableAsync("stillInterested", tableQuery);
if (messages.Any(x => !x.ReceivedAnswer))
{
foreach (var message in messages.Where(x => !x.ReceivedAnswer))
{
var conversationReference = JsonConvert.DeserializeObject <ConversationReference>(message.ConversationReference).GetPostToBotMessage();
var client = new ConnectorClient(new Uri(conversationReference.ServiceUrl));
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, conversationReference))
{
var botData = scope.Resolve <IBotData>();
await botData.LoadAsync(CancellationToken.None);
var task = scope.Resolve <IDialogTask>();
//interrupt the stack
var dialog = new StillInterestedDialog(message);
task.Call(dialog.Void <object, IMessageActivity>(), null);
await task.PollAsync(CancellationToken.None);
//flush dialog stack
await botData.FlushAsync(CancellationToken.None);
}
}
await tableStorageProvider.DeleteFromTableAsync("stillInterested", messages);
}
} while (messages.Any());
Thread.Sleep(TimeSpan.FromHours(configurationProvider.GetConfiguration <int>("stillInterestedPollIntervalHours")));
}
}
public static string FilterString(string propertyName, string queryComparison, object value)
{
var filterString = "";
var val = "";
if (value != null)
{
val = value.GetType().ToString().Replace("System.", "");
}
switch (val)
{
//case "":
// filterString = TableQuery.GenerateFilterCondition(property, queryComparison, "");
// break;
case "Byte[]":
filterString = TableQuery.GenerateFilterConditionForBinary(propertyName, queryComparison, (byte[])value);
break;
case "Boolean":
filterString = TableQuery.GenerateFilterConditionForBool(propertyName, queryComparison, (bool)value);
break;
case "DateTime":
filterString = TableQuery.GenerateFilterConditionForDate(propertyName, queryComparison, (DateTime)value);
break;
case "Double":
filterString = TableQuery.GenerateFilterConditionForDouble(propertyName, queryComparison, (double)value);
break;
case "Guid":
filterString = TableQuery.GenerateFilterConditionForGuid(propertyName, queryComparison, (Guid)value);
break;
case "Int32":
filterString = TableQuery.GenerateFilterConditionForInt(propertyName, queryComparison, (int)value);
break;
case "Int64":
filterString = TableQuery.GenerateFilterConditionForLong(propertyName, queryComparison, (long)value);
break;
default:
//if (Utils.IsRowKey(property))
// filterString = TableQuery.GenerateFilterCondition("RowKey", queryComparison, (String)value);
//else
//if (Utils.IsPartitionKey(property))
// filterString = TableQuery.GenerateFilterCondition("PartitionKey", queryComparison, (String)value);
//else
filterString = TableQuery.GenerateFilterCondition(propertyName, queryComparison, (String)value);
break;
}
//Event("Type Not Handled error on QueryOn");
return(filterString);
}
public override string ToString()
{
var filterOperation = QueryComparisons.Equal;
switch (Operator)
{
case QueryFilterOperator.Equal:
filterOperation = QueryComparisons.Equal;
break;
case QueryFilterOperator.NotEqual:
filterOperation = QueryComparisons.NotEqual;
break;
case QueryFilterOperator.Lower:
filterOperation = QueryComparisons.LessThan;
break;
case QueryFilterOperator.Greater:
filterOperation = QueryComparisons.GreaterThan;
break;
case QueryFilterOperator.LowerEqual:
filterOperation = QueryComparisons.LessThanOrEqual;
break;
case QueryFilterOperator.GreaterEqual:
filterOperation = QueryComparisons.GreaterThanOrEqual;
break;
}
if (Value is string)
{
return(TableQuery.GenerateFilterCondition(Property, filterOperation, (string)Value));
}
if (Value is bool)
{
return(TableQuery.GenerateFilterConditionForBool(Property, filterOperation, (bool)Value));
}
if (Value is byte[])
{
return(TableQuery.GenerateFilterConditionForBinary(Property, filterOperation, (byte[])Value));
}
if (Value is DateTimeOffset)
{
return(TableQuery.GenerateFilterConditionForDate(Property, filterOperation, (DateTimeOffset)Value));
}
if (Value is double)
{
return(TableQuery.GenerateFilterConditionForDouble(Property, filterOperation, (double)Value));
}
if (Value is Guid)
{
return(TableQuery.GenerateFilterConditionForGuid(Property, filterOperation, (Guid)Value));
}
if (Value is int)
{
return(TableQuery.GenerateFilterConditionForInt(Property, filterOperation, (int)Value));
}
if (Value is long)
{
return(TableQuery.GenerateFilterConditionForLong(Property, filterOperation, (long)Value));
}
throw new NotSupportedException($"QueryFilter of Type \"{Value?.GetType().FullName}\" is not supported.");
}