public async Task <ActionResult> EditRuleProperties(string deviceId, string ruleId)
{
EditDeviceRuleModel editModel = null;
//empty ruleId implies that we are creating new
if (string.IsNullOrWhiteSpace(ruleId))
{
bool canCreate = await _deviceRulesLogic.CanNewRuleBeCreatedForDeviceAsync(deviceId);
if (!canCreate)
{
editModel = new EditDeviceRuleModel()
{
DeviceID = deviceId
};
return(View("AllRulesAssigned", editModel));
}
}
DeviceRule ruleModel = await _deviceRulesLogic.GetDeviceRuleOrDefaultAsync(deviceId, ruleId);
Dictionary <string, List <string> > availableFields = await _deviceRulesLogic.GetAvailableFieldsForDeviceRuleAsync(ruleModel.DeviceID, ruleModel.RuleId);
List <SelectListItem> availableDataFields = this.ConvertStringListToSelectList(availableFields["availableDataFields"]);
List <SelectListItem> availableOperators = this.ConvertStringListToSelectList(availableFields["availableOperators"]);
List <SelectListItem> availableRuleOutputs = this.ConvertStringListToSelectList(availableFields["availableRuleOutputs"]);
editModel = CreateEditModelFromDeviceRule(ruleModel);
editModel.AvailableDataFields = availableDataFields;
editModel.AvailableOperators = availableOperators;
editModel.AvailableRuleOutputs = availableRuleOutputs;
return(View("EditDeviceRuleProperties", editModel));
}
public async Task <ActionResult> UpdateRuleEnabledState(EditDeviceRuleModel ruleModel)
{
TableStorageResponse <DeviceRule> response = await _deviceRulesLogic.UpdateDeviceRuleEnabledStateAsync(ruleModel.DeviceID,
ruleModel.RuleId, ruleModel.EnabledState);
return(BuildRuleUpdateResponse(response));
}
public async Task <ActionResult> GetRuleProperties(string deviceId, string ruleId)
{
DeviceRule rule = await _deviceRulesLogic.GetDeviceRuleAsync(deviceId, ruleId);
EditDeviceRuleModel editModel = CreateEditModelFromDeviceRule(rule);
return(PartialView("_DeviceRuleProperties", editModel));
}
public async Task <ActionResult> RemoveRule(string deviceId, string ruleId)
{
DeviceRule ruleModel = await _deviceRulesLogic.GetDeviceRuleOrDefaultAsync(deviceId, ruleId);
EditDeviceRuleModel editModel = CreateEditModelFromDeviceRule(ruleModel);
return(View("RemoveDeviceRule", editModel));
}
public async Task <ActionResult> UpdateRuleProperties(EditDeviceRuleModel model)
{
string errorMessage = model.CheckForErrorMessage();
if (!string.IsNullOrWhiteSpace(errorMessage))
{
return(Json(new { error = errorMessage }));
}
DeviceRule rule = CreateDeviceRuleFromEditModel(model);
TableStorageResponse <DeviceRule> response = await _deviceRulesLogic.SaveDeviceRuleAsync(rule);
return(BuildRuleUpdateResponse(response));
}
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);
}
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);
}
