/// <summary> /// Retrieve an existing rule for editing. If none is found then a default, bare-bones rule is returned for creating new /// A new rule is not persisted until it is saved. Distinct Rules are defined by the combination key of deviceID and ruleId /// /// Use this method if you are not sure the desired rule exists /// </summary> /// <param name="deviceId"></param> /// <param name="ruleId"></param> /// <returns></returns> public async Task<DeviceRule> GetDeviceRuleOrDefaultAsync(string deviceId, string ruleId) { List<DeviceRule> rulesForDevice = await _deviceRulesRepository.GetAllRulesForDeviceAsync(deviceId); foreach(DeviceRule rule in rulesForDevice) { if(rule.RuleId == ruleId) { return rule; } } var createdRule = new DeviceRule(); createdRule.InitializeNewRule(deviceId); return createdRule; }
/// <summary> /// Save a rule to the data store. This method should be used for new rules as well as updating existing rules /// </summary> /// <param name="updatedRule"></param> /// <returns></returns> public async Task<TableStorageResponse<DeviceRule>> SaveDeviceRuleAsync(DeviceRule updatedRule) { //Enforce single instance of a rule for a data field for a given device List<DeviceRule> foundForDevice = await _deviceRulesRepository.GetAllRulesForDeviceAsync(updatedRule.DeviceID); foreach(DeviceRule rule in foundForDevice) { if(rule.DataField == updatedRule.DataField && rule.RuleId != updatedRule.RuleId) { var response = new TableStorageResponse<DeviceRule>(); response.Entity = rule; response.Status = TableStorageResponseStatus.DuplicateInsert; return response; } } return await _deviceRulesRepository.SaveDeviceRuleAsync(updatedRule); }
public async void SaveDeviceRuleAsyncTest() { var deviceId = fixture.Create<string>(); var rules = fixture.Create<List<DeviceRule>>(); rules.ForEach(x => x.DeviceID = deviceId); _deviceRulesRepositoryMock.Setup(x => x.GetAllRulesForDeviceAsync(deviceId)).ReturnsAsync(rules); _deviceRulesRepositoryMock.Setup(x => x.SaveDeviceRuleAsync(It.IsNotNull<DeviceRule>())) .ReturnsAsync(new TableStorageResponse<DeviceRule>()); var newRule = new DeviceRule(); newRule.InitializeNewRule(deviceId); newRule.DataField = rules[0].DataField; var ret = await deviceRulesLogic.SaveDeviceRuleAsync(newRule); Assert.NotNull(ret.Entity); Assert.Equal(TableStorageResponseStatus.DuplicateInsert, ret.Status); newRule.InitializeNewRule(deviceId); newRule.DataField = "New data in DataField"; ret = await deviceRulesLogic.SaveDeviceRuleAsync(newRule); Assert.NotNull(ret); }
public async Task<HttpResponseMessage> SaveDeviceRuleAsync(DeviceRule updatedRule) { return await GetServiceResponseAsync<TableStorageResponse<DeviceRule>>(async () => { return await _deviceRulesLogic.SaveDeviceRuleAsync(updatedRule); }); }
/// <summary> /// Generate a new rule with bare-bones configuration. This new rule can then be conigured and sent /// back through the SaveDeviceRuleAsync method to persist. /// </summary> /// <param name="deviceId"></param> /// <returns></returns> public async Task<DeviceRule> GetNewRuleAsync(string deviceId) { return await Task.Run(() => { var rule = new DeviceRule(); rule.InitializeNewRule(deviceId); return rule; }); }
private EditDeviceRuleModel CreateEditModelFromDeviceRule(DeviceRule rule) { EditDeviceRuleModel editModel = new EditDeviceRuleModel(); editModel.RuleId = rule.RuleId; editModel.DataField = rule.DataField; editModel.DeviceID = rule.DeviceID; editModel.EnabledState = rule.EnabledState; editModel.Etag = rule.Etag; editModel.Operator = rule.Operator; editModel.RuleOutput = rule.RuleOutput; if (rule.Threshold != null) { editModel.Threshold = rule.Threshold.ToString(); } return editModel; }
private DeviceRule CreateDeviceRuleFromEditModel(EditDeviceRuleModel editModel) { DeviceRule rule = new DeviceRule(editModel.RuleId); rule.DataField = editModel.DataField; rule.DeviceID = editModel.DeviceID; rule.EnabledState = editModel.EnabledState; rule.Etag = editModel.Etag; rule.Operator = editModel.Operator; rule.RuleOutput = editModel.RuleOutput; if (!string.IsNullOrWhiteSpace(editModel.Threshold)) { rule.Threshold = double.Parse( editModel.Threshold, NumberStyles.Float, CultureInfo.CurrentCulture); } return rule; }
private DeviceRule BuildRuleFromTableEntity(DeviceRuleTableEntity tableEntity) { if(tableEntity == null) { return null; } var updatedRule = new DeviceRule(tableEntity.RuleId) { DeviceID = tableEntity.DeviceId, DataField = tableEntity.DataField, Threshold = tableEntity.Threshold, EnabledState = tableEntity.Enabled, Operator = ">", RuleOutput = tableEntity.RuleOutput, Etag = tableEntity.ETag }; return updatedRule; }
/// <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; }
private DeviceRuleTableEntity BuildTableEntityFromRule(DeviceRule incomingRule) { DeviceRuleTableEntity tableEntity = new DeviceRuleTableEntity(incomingRule.DeviceID, incomingRule.RuleId) { DataField = incomingRule.DataField, Threshold = (double)incomingRule.Threshold, Enabled = incomingRule.EnabledState, RuleOutput = incomingRule.RuleOutput }; if (!string.IsNullOrWhiteSpace(incomingRule.Etag)) { tableEntity.ETag = incomingRule.Etag; } return tableEntity; }
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; }