public async Task <IEnumerable <Prediction> > GetLatestPrediction(string deviceId)
{
var storageConnectionString = _settings.StorageConnectionString;
var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.PredictionTableName);
var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime;
var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId);
var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime);
var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter);
TableQuery <PredictionRecord> query = new TableQuery <PredictionRecord>()
.Where(filter)
.Take(MaxRecordsToReceive)
.Select(new[] { "Timestamp", "Rul" });
var result = new Collection <Prediction>();
var entities = table.ExecuteQuery(query)
.OrderByDescending(x => x.RowKey)
.Take(MaxRecordsToSend);
foreach (var entity in entities)
{
var prediction = new Prediction
{
DeviceId = entity.PartitionKey,
Timestamp = entity.Timestamp.DateTime,
RemainingUsefulLife = (int)double.Parse(entity.Rul),
Cycles = int.Parse(entity.RowKey)
};
result.Add(prediction);
}
return(result.OrderBy(x => x.Cycles));
}
public async Task <TableStorageResponse <UserSetting> > SetUserSettingValueAsync(UserSetting setting)
{
var incomingEntity =
new UserSettingTableEntity()
{
PartitionKey = _settingsTablePartitionKey,
RowKey = setting.Key,
SettingValue = setting.Value
};
if (!string.IsNullOrWhiteSpace(setting.Etag))
{
incomingEntity.ETag = setting.Etag;
}
TableStorageResponse <UserSetting> result = await AzureTableStorageHelper.DoTableInsertOrReplaceAsync <UserSetting, UserSettingTableEntity>(incomingEntity, (tableEntity) =>
{
if (tableEntity == null)
{
return(null);
}
var updatedSetting = new UserSetting()
{
Key = tableEntity.RowKey,
Value = tableEntity.SettingValue,
Etag = tableEntity.ETag
};
return(updatedSetting);
}, _storageAccountConnectionString, _settingsTableName);
return(result);
}
/// <summary>
/// Assess the self-set quota policy and number of recent calls made, and ensure that we don't exceed that number. This thread
/// blocks if the limit set has been reached, until it is back under the required threshold
/// </summary>
/// <param name="identifierForThrottlingRecords">Identifier to use to track API calls to monitor calls against threshold</param>
/// <param name="apiName">Name of the API against which calls are being monitored</param>
private void ExecuteSelfThrottlingPolicy(string identifierForThrottlingRecords, string apiName)
{
switch (_selfThrottlingMethod)
{
case SelfThrottlingMethod.InMemoryCallRecollection:
// Check if we have hit our limit for number of calls to the API
while (!this.VerifyInMemoryThrottledCallCanProceed())
{
Logger.Information($"Delaying issueing call to {apiName} API to ensure API throttling isn't exceeded at {DateTime.UtcNow}", "ApiInteractionHelper: ExecuteThrottledApiCall()");
Thread.Sleep(500);
}
// Add this call to the call tracker
this.recentApiCalls.Add(DateTime.UtcNow);
break;
case SelfThrottlingMethod.AzureTableStorageCallRecollection:
// Check if we have hit our limit for number of calls to the API
while (!this.VerifyAzureTableStorageThrottledCallCanProceed(identifierForThrottlingRecords, apiName))
{
Logger.Information($"Delaying issueing call to {apiName} API to ensure API throttling isn't exceeded at {DateTime.UtcNow}", "ApiInteractionHelper: ExecuteThrottledApiCall()");
Thread.Sleep(500);
}
// Add this call to the call tracker
AzureTableStorageHelper.LogApiCallToTableStorage(new ApiCallRecordTableEntity(identifierForThrottlingRecords, apiName));
break;
case SelfThrottlingMethod.None:
default:
// Apply no throttling - proceed with call
break;
}
}
/// <summary>
/// Return true if the number of calls to the API has not exceeded the maximum number of calls per minute in the last minute
/// </summary>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool VerifyAzureTableStorageThrottledCallCanProceed(string apiKey, string apiName)
{
// Now check if we have capacity in our allocation to make a call now
bool canProceed = true;
// Check per minute limit
var dateFromLastMinute = DateTime.UtcNow.AddMinutes(-1);
var dateToLastMinute = DateTime.UtcNow.AddMinutes(1);
var messages = AzureTableStorageHelper.RetrieveLogMessagesFromTableStorage(apiKey, dateFromLastMinute, dateToLastMinute);
if ((messages != null) && (messages.Count() >= this.maxNumberOfCallsPerMinute))
{
canProceed = false;
}
// Check Daily limit
var dateFromLastDay = DateTime.UtcNow.AddDays(-1);
var dateTimeNow = DateTime.UtcNow.AddMinutes(1);
var daySpanMessages = AzureTableStorageHelper.RetrieveLogMessagesFromTableStorage(apiKey, dateFromLastDay, dateTimeNow);
if ((daySpanMessages != null) && (daySpanMessages.Count() >= this.maxNumberOfCallsPerDay))
{
canProceed = false;
}
return(canProceed);
}
/// <summary>
/// Save a Device Rule to the server. This may be either a new rule or an update to an existing rule.
/// </summary>
/// <param name="updateContainer"></param>
/// <returns></returns>
public async Task <TableStorageResponse <DeviceRule> > SaveDeviceRuleAsync(DeviceRule updatedRule)
{
DeviceRuleTableEntity incomingEntity =
new DeviceRuleTableEntity(updatedRule.DeviceID, updatedRule.RuleId)
{
DataField = updatedRule.DataField,
Threshold = (double)updatedRule.Threshold,
Enabled = updatedRule.EnabledState,
RuleOutput = updatedRule.RuleOutput
};
if (!string.IsNullOrWhiteSpace(updatedRule.Etag))
{
incomingEntity.ETag = updatedRule.Etag;
}
TableStorageResponse <DeviceRule> result =
await AzureTableStorageHelper.DoTableInsertOrReplace <DeviceRule, DeviceRuleTableEntity>(incomingEntity, BuildRuleFromTableEntity,
_storageAccountConnectionString, _deviceRulesNormalizedTableName);
// Build up a new blob to push up
List <DeviceRuleBlobEntity> blobList = await BuildBlobEntityListFromTableRows();
await PersistRulesToBlobStorageAsync(blobList);
return(result);
}
public override async Task ProcessItem(dynamic eventData)
{
// Ensure this is a correctly-formatted event for ML; ignore it otherwise
if (eventData == null || eventData.deviceid == null || eventData.cycle == null ||
eventData.sensor9 == null || eventData.sensor11 == null || eventData.sensor14 == null || eventData.sensor15 == null)
{
return;
}
// The experiment theoretically supports multiple inputs at once,
// even though we only get one value at a time, so the request
// requires an array of inputs
MLRequest mlRequest = new MLRequest(ML_REQUEST_COLUMNS, new string[, ]
{
{
// The id is required to be numeric, so we hash the actual device id
eventData.deviceid.ToString().GetHashCode().ToString(),
// The remaining entries are string representations of the numeric values
eventData.cycle.ToString(),
eventData.sensor9.ToString(),
eventData.sensor11.ToString(),
eventData.sensor14.ToString(),
eventData.sensor15.ToString()
}
}
);
HttpClient http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _configurationProvider.GetConfigurationSettingValue("MLApiKey"));
http.BaseAddress = new Uri(_configurationProvider.GetConfigurationSettingValue("MLApiUrl") + ML_ENDPOINT);
HttpResponseMessage response = await http.PostAsJsonAsync("", mlRequest);
if (response.IsSuccessStatusCode)
{
MLResponse result = JsonConvert.DeserializeObject <MLResponse>(await response.Content.ReadAsStringAsync());
RulTableEntity entry = new RulTableEntity
{
PartitionKey = eventData.deviceid.ToString(),
RowKey = eventData.cycle.ToString(),
// Extract the single relevant RUL value from the JSON output
Rul = result.Results["data"].value.Values[0, RUL_COLUMN],
// Since the simulator might replay data, ensure we can overwrite table values
ETag = "*"
};
// We don't need a data model to represent the result of this operation,
// so we use a stub table/model convertor
await AzureTableStorageHelper.DoTableInsertOrReplaceAsync <object, RulTableEntity>(entry, (RulTableEntity e) => null,
_configurationProvider.GetConfigurationSettingValue("eventHub.StorageConnectionString"),
_configurationProvider.GetConfigurationSettingValue("MLResultTableName"));
}
else
{
throw new Exception(string.Format("The ML request failed with status code: {0}", response.StatusCode));
}
}
async void ClearTables()
{
var telemetryTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _telemetryTableName);
var mlTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _mlResultTableName);
ClearTable(telemetryTable);
ClearTable(mlTable);
}
private async Task <IEnumerable <DeviceRuleTableEntity> > GetAllRulesFromTable()
{
var deviceRulesTable = await AzureTableStorageHelper.GetTableAsync(_storageAccountConnectionString, _deviceRulesNormalizedTableName);
TableQuery <DeviceRuleTableEntity> query = new TableQuery <DeviceRuleTableEntity>();
return(await Task.Run(() =>
deviceRulesTable.ExecuteQuery(query)
));
}
public async Task <string> GetSimulationState()
{
var table = await AzureTableStorageHelper.GetTableAsync(this.storageConnectionString, "simulatorstate");
var query = new TableQuery <StateTableEntity>()
.Take(1)
.Select(new[] { "State" });
var result = table.ExecuteQuery(query);
var stateEntity = result.FirstOrDefault();
return(stateEntity != null ? stateEntity.State : StartStopConstants.STOPPED);
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
var deviceEnity = new DeviceListEntity()
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await devicesTable.ExecuteAsync(operation);
}
/// <summary>
/// Retrieve a single rule from AzureTableStorage or default if none exists.
/// A distinct rule is defined by the combination key deviceID/DataField
/// </summary>
/// <param name="deviceId"></param>
/// <param name="dataField"></param>
/// <returns></returns>
public async Task <DeviceRule> GetDeviceRuleAsync(string deviceId, string ruleId)
{
var deviceRulesTable = await AzureTableStorageHelper.GetTableAsync(_storageAccountConnectionString, _deviceRulesNormalizedTableName);
TableOperation query = TableOperation.Retrieve <DeviceRuleTableEntity>(deviceId, ruleId);
TableResult response = await Task.Run(() =>
deviceRulesTable.Execute(query)
);
DeviceRule result = BuildRuleFromTableEntity((DeviceRuleTableEntity)response.Result);
return(result);
}
public static async Task Write(string device, string state, string connectionString, string table)
{
StateTableEntity entry = new StateTableEntity
{
PartitionKey = device,
RowKey = "State", // Arbitrary constant; we're only storing one value per device
State = state,
ETag = "*"
};
// We don't need a data model to represent the result of this operation,
// so we use a stub table/model convertor
await AzureTableStorageHelper.DoTableInsertOrReplaceAsync <object, StateTableEntity>(entry, (StateTableEntity e) => { return(null); }, connectionString, table);
}
/// <summary>
/// Retrieve all rules from the database that have been defined for a single device.
/// If none exist an empty list will be returned. This method guarantees a non-null
/// result.
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public async Task <List <DeviceRule> > GetAllRulesForDeviceAsync(string deviceId)
{
var deviceRulesTable = await AzureTableStorageHelper.GetTableAsync(_storageAccountConnectionString, _deviceRulesNormalizedTableName);
TableQuery <DeviceRuleTableEntity> query = new TableQuery <DeviceRuleTableEntity>().
Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId));
List <DeviceRule> result = new List <DeviceRule>();
foreach (DeviceRuleTableEntity entity in deviceRulesTable.ExecuteQuery(query))
{
result.Add(BuildRuleFromTableEntity(entity));
}
return(result);
}
public async Task Initialize()
{
Mock <ILoggerFactory> factory = new Mock <ILoggerFactory>();
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
var _dbconfig = config.GetSection("CosmoDBSettings").Get <CosmoDBSettings>();
_repository = new RawEventStorageRepository(new CosmoDBStorageInitializer(_dbconfig), factory.Object);
await AzureTableStorageHelper.EnsurePersonIsInLocalStorage(_context, _userId, _userPersonalInfo.Initials, _userPersonalInfo.LastNameAtBirth, _userPersonalInfo.LastNameAtBirthPrefix, _userPersonalInfo.BirthDate);
await AzureTableStorageHelper.EnsurePersonIsInLocalStorage(_context, _targetId, _targetPersonalInfo.Initials, _targetPersonalInfo.LastNameAtBirth, _targetPersonalInfo.LastNameAtBirthPrefix, _targetPersonalInfo.BirthDate);
}
public async Task CleanUp()
{
foreach (string eventId in _eventIdList)
{
await _repository.DeleteRawEventAsync(eventId, new RequestOptions()
{
PartitionKey = new Microsoft.Azure.Documents.PartitionKey(Microsoft.Azure.Documents.Undefined.Value)
});
}
_eventIdList.Clear();
await AzureTableStorageHelper.CleanUpPersonFromLocalStorage(_context, _userId);
await AzureTableStorageHelper.CleanUpPersonFromLocalStorage(_context, _targetId);
}
private async Task <InitialDeviceConfig> GetDeviceAsync(TableQuery <DeviceListEntity> query)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
foreach (var device in devicesTable.ExecuteQuery <DeviceListEntity>(query))
{
// Always return first device found
return(new InitialDeviceConfig
{
DeviceId = device.DeviceId,
HostName = device.HostName,
Key = device.Key
});
}
return(null);
}
public async Task <TableStorageResponse <DeviceRule> > DeleteDeviceRuleAsync(DeviceRule ruleToDelete)
{
DeviceRuleTableEntity incomingEntity = BuildTableEntityFromRule(ruleToDelete);
TableStorageResponse <DeviceRule> result =
await AzureTableStorageHelper.DoDeleteAsync <DeviceRule, DeviceRuleTableEntity>(incomingEntity, BuildRuleFromTableEntity,
_storageAccountConnectionString, _deviceRulesNormalizedTableName);
if (result.Status == TableStorageResponseStatus.Successful)
{
// Build up a new blob to push up for ASA job ref data
List <DeviceRuleBlobEntity> blobList = await BuildBlobEntityListFromTableRows();
await PersistRulesToBlobStorageAsync(blobList);
}
return(result);
}
public async Task <List <InitialDeviceConfig> > GetDeviceListAsync()
{
List <InitialDeviceConfig> devices = new List <InitialDeviceConfig>();
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
TableQuery <DeviceListEntity> query = new TableQuery <DeviceListEntity>();
foreach (var device in devicesTable.ExecuteQuery(query))
{
var deviceConfig = new InitialDeviceConfig()
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return(devices);
}
/// <summary>
/// Return true if the number of calls to the API has not exceeded the maximum number of calls per minute in the last minute
/// </summary>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool VerifyAzureTableStorageThrottledCallCanProceed(string apiKey, string apiName)
{
// Now check if we have capacity in our allocation to make a call now
var dateFromLastMinute = DateTime.UtcNow.AddMinutes(-1);
var dateToLastMinute = DateTime.UtcNow.AddMinutes(1);
var messages = AzureTableStorageHelper.RetrieveLogMessagesFromTableStorage(apiKey, dateFromLastMinute, dateToLastMinute);
if (messages == null)
{
return(true);
}
if (messages.Count() >= this.maxNumberOfCallsPerMinute)
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// Make a call to an API with the given details, and apply the specified self-throttling method
/// </summary>
/// <typeparam name="T">Type to desearalize the data returned into</typeparam>
/// <param name="timeout">Optional time to give up after</param>
/// <param name="webApiHelper">WebApiSerializerHelper of a given type</param>
/// <param name="apiQueryUrl">URL of the API</param>
/// <param name="urlParameters">Optional paramaters for the API call</param>
/// <param name="apiKey">Optional APIKey for the API</param>
/// <param name="apiName">Optional Name of the API for logging</param>
/// <returns>Results of the API call, desearilized into the given object type</returns>
public T ExecuteThrottledApiCall <T>(
TimeSpan?timeout,
WebApiSerializerHelper <T> webApiHelper,
string apiQueryUrl, string urlParameters, string apiKey = null, string apiName = null)
{
switch (_selfThrottlingMethod)
{
case SelfThrottlingMethod.InMemoryCallRecollection:
// Check if we have hit our limit for number of calls to the API
while (!this.VerifyInMemoryThrottledCallCanProceed())
{
Logger.Information($"Delaying issueing call to {apiName} API to ensure API throttling isn't exceeded at {DateTime.UtcNow}", "ApiInteractionHelper: ExecuteThrottledApiCall()");
Thread.Sleep(500);
}
// Add this call to the call tracker
this.recentApiCalls.Add(DateTime.UtcNow);
break;
case SelfThrottlingMethod.AzureTableStorageCallRecollection:
// Check if we have hit our limit for number of calls to the API
while (!this.VerifyAzureTableStorageThrottledCallCanProceed(apiKey, apiName))
{
Logger.Information($"Delaying issueing call to {apiName} API to ensure API throttling isn't exceeded at {DateTime.UtcNow}", "ApiInteractionHelper: ExecuteThrottledApiCall()");
Thread.Sleep(500);
}
// Add this call to the call tracker
AzureTableStorageHelper.LogApiCallToTableStorage(new ApiCallRecordTableEntity(apiKey, apiName));
break;
case SelfThrottlingMethod.None:
default:
// Apply no throttling - proceed with call
break;
}
var response = webApiHelper.GetHttpResponseContentAsType <T>(apiQueryUrl, urlParameters, timeout, apiKey).Result;
return(response);
}
public async Task <bool> RemoveDeviceAsync(string deviceId)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
var device = await this.GetDeviceAsync(deviceId);
if (device != null)
{
var operation = TableOperation.Retrieve <DeviceListEntity>(device.DeviceId, device.HostName);
var result = await devicesTable.ExecuteAsync(operation);
var deleteDevice = (DeviceListEntity)result.Result;
if (deleteDevice != null)
{
var deleteOperation = TableOperation.Delete(deleteDevice);
await devicesTable.ExecuteAsync(deleteOperation);
return(true);
}
}
return(false);
}
public async Task RepositoryIsAbleToConnectAndManagePersonalInfo()
{
var initializer = AzureTableStorageHelper.InitializeTableStorage();
var repo = new AzureTableStorageRepository <StoredPersonalInfo>(initializer, new Mock <ILogger>().Object);
var partitionKey = "AzureTableStorageClientIntegrationTests";
var rowKey = "R234568";
// Clean up
var sut = await repo.RetrieveRecord(partitionKey, rowKey);
if (sut != null)
{
await repo.DeleteRecord(sut);
}
// Insert
await repo.InsertRecordToTable(new StoredPersonalInfo()
{
PartitionKey = partitionKey,
RowKey = rowKey,
initials = "AP",
lastNameAtBirthPrefix = "Aylen Perez",
lastNameAtBirth = "",
birthdate = "28/09/1976"
});
sut = await repo.RetrieveRecord(partitionKey, rowKey);
Assert.IsNotNull(sut);
Assert.IsInstanceOfType(sut, typeof(StoredPersonalInfo));
// Delete
await repo.DeleteRecord(sut);
sut = await repo.RetrieveRecord(partitionKey, rowKey);
Assert.IsNull(sut);
}
public override async Task ProcessItem(dynamic eventData)
{
// Ensure this is a correctly-formatted event for ML; ignore it otherwise
if (eventData == null || eventData.deviceid == null || eventData.cycle == null ||
eventData.sensor9 == null || eventData.sensor11 == null || eventData.sensor14 == null || eventData.sensor15 == null)
{
return;
}
string result = await _mlServiceInvoker.GetRULAsync(
// The id is required to be numeric, so we hash the actual device id
eventData.deviceid.ToString().GetHashCode().ToString(),
// The remaining entries are string representations of the numeric values
eventData.cycle.ToString(),
eventData.sensor9.ToString(),
eventData.sensor11.ToString(),
eventData.sensor14.ToString(),
eventData.sensor15.ToString()
);
Trace.TraceInformation($"RUL Result: {result}");
RulTableEntity entry = new RulTableEntity
{
PartitionKey = eventData.deviceid.ToString(),
RowKey = eventData.cycle.ToString(),
// Extract the single relevant RUL value from the JSON output
Rul = result,
// Since the simulator might replay data, ensure we can overwrite table values
ETag = "*"
};
// We don't need a data model to represent the result of this operation,
// so we use a stub table/model convertor
await AzureTableStorageHelper.DoTableInsertOrReplaceAsync <object, RulTableEntity>(entry, (RulTableEntity e) => null,
_configurationProvider.GetConfigurationSettingValue("eventHub.StorageConnectionString"),
_configurationProvider.GetConfigurationSettingValue("MLResultTableName"));
}
public async Task <IEnumerable <Telemetry> > GetLatestTelemetry(string deviceId)
{
var storageConnectionString = _settings.StorageConnectionString;
var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.TelemetryTableName);
var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime;
var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId);
var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime);
var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter);
TableQuery <TelemetryEntity> query = new TableQuery <TelemetryEntity>()
.Where(filter)
.Take(MaxRecordsToReceive)
.Select(new[] { "sensor11", "sensor14", "sensor15", "sensor9" });
var result = new Collection <Telemetry>();
var entities = table.ExecuteQuery(query)
.OrderByDescending(x => x.Timestamp)
.Take(MaxRecordsToSend);
foreach (var entity in entities)
{
var telemetry = new Telemetry
{
DeviceId = entity.PartitionKey,
RecordId = entity.RowKey,
Timestamp = entity.Timestamp.DateTime,
Sensor1 = Math.Round(double.Parse(entity.sensor11)),
Sensor2 = Math.Round(double.Parse(entity.sensor14)),
Sensor3 = Math.Round(double.Parse(entity.sensor15)),
Sensor4 = Math.Round(double.Parse(entity.sensor9))
};
result.Add(telemetry);
}
return(result.OrderBy(x => x.Timestamp));
}
public async Task RepositoryIsAbleToConnectAndManageContextMappings()
{
var initializer = AzureTableStorageHelper.InitializeTableStorage();
var repo = new AzureTableStorageRepository <ContextMapping>(initializer, new Mock <ILogger>().Object);
var partitionKey = "PersonInfo";
var rowKey = "AzureTableStorageClientIntegrationTests";
// Clean up
var sut = await repo.RetrieveRecord(partitionKey, rowKey);
if (sut != null)
{
await repo.DeleteRecord(sut);
}
// Insert
await repo.InsertRecordToTable(new ContextMapping()
{
PartitionKey = partitionKey,
RowKey = rowKey,
URL = "http://localhost:9002/youforcereseolver"
});
sut = await repo.RetrieveRecord(partitionKey, rowKey);
Assert.IsNotNull(sut);
Assert.IsInstanceOfType(sut, typeof(ContextMapping));
Assert.IsFalse(string.IsNullOrEmpty(sut.URL));
// Delete
await repo.DeleteRecord(sut);
sut = await repo.RetrieveRecord(partitionKey, rowKey);
Assert.IsNull(sut);
}
public async Task <UserSetting> GetUserSettingValueAsync(string settingKey)
{
var settingsTable = await AzureTableStorageHelper.GetTableAsync(_storageAccountConnectionString, _settingsTableName);
TableOperation query = TableOperation.Retrieve <UserSettingTableEntity>(_settingsTablePartitionKey, settingKey);
TableResult response = await Task.Run(() =>
settingsTable.Execute(query)
);
UserSetting result = null;
if (response.Result != null && response.Result.GetType() == typeof(UserSettingTableEntity))
{
result = new UserSetting
{
Etag = ((UserSettingTableEntity)response.Result).ETag,
Key = ((UserSettingTableEntity)response.Result).RowKey,
Value = ((UserSettingTableEntity)response.Result).SettingValue
};
}
return(result);
}
public ApiRegistrationRepository(IConfigurationProvider configProvider)
{
_table = AzureTableStorageHelper.GetTable(
configProvider.GetConfigurationSettingValue("device.StorageConnectionString"), API_TABLE_NAME);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommentsActivity" /> class.
/// </summary>
public CommentsActivity()
{
this.azureTableStorageHelper = new AzureTableStorageHelper();
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeOffActivity" /> class.
/// </summary>
public TimeOffActivity()
{
this.azureTableStorageHelper = new AzureTableStorageHelper();
}
/// <summary>
/// Initializes a new instance of the <see cref="SupervisorViewTimeOffActivity" /> class.
/// </summary>
public SupervisorViewTimeOffActivity()
{
this.azureTableStorageHelper = new AzureTableStorageHelper();
}