public void RuleRepositoryTest_Rules_DeleteRule_validModel()
{
var model = new RuleModel
{
RuleId = 99,
Category = "newcategory",
Text = "textnew",
Title = "newtitle"
};
var result = rep.Delete(model.RuleId);
Assert.AreEqual(model.RuleId, result, string.Format("result != expected"));
}
public string Delete(int id)
{
if (!id.Validate())
{
throw new Exception("Invalid model");
}
return(rep.Delete(id) > 0
? "Delete completed successful"
: null);
}
public async Task <IActionResult> Delete(int Id)
{
var rule = await ruleRepository.GetById(User, Id);
var deviceId = rule.DeviceId;
await ruleRepository.Delete(User, Id);
return(RedirectToAction(nameof(Index), new { deviceId }));
}
public bool Delete(int id)
{
return(iRuleRepostory.Delete(id));
}
public void Delete(int Id)
{
_ruleRepository.Delete(Id);
}
public IHttpActionResult Put([FromUri] int id, [FromBody] RuleTypeModel command)
{
if (command == null)
{
return(BadRequest("Entity can not be null"));
}
if (command.Id != id)
{
return(BadRequest("Model id does not match"));
}
if (!ModelState.IsValid || command.Rules == null || !command.Rules.Any())
{
return(this.Error().InvalidParameters("Invalid rule type parameters"));
}
var targetRuleType = _ruleTypeRepository.Get(id);
if (targetRuleType is null)
{
return(NotFound());
}
// Update rule type
targetRuleType.Name = command.Name;
_ruleTypeRepository.Update(targetRuleType);
_ruleTypeRepository.SaveChanges();
var rules = _ruleRepository.FindByRuleTypeId(targetRuleType.Id);
var deletedRuleIds = rules.Where(r => command.Rules.All(cr => r.Id != cr.Id))
.Select(r => new { r.Id, r.RuleId })
.ToList();
var maxRuleId = command.Rules.Max(r => r.RuleId) + 1;
var newRuleIds = new List <int>();
// Upsert rules per rule type
foreach (var ruleItem in command.Rules)
{
var rule = _ruleRepository.Get(ruleItem.Id);
if (rule != null)
{
rule.Description = ruleItem.Description;
rule.InternalType = ruleItem.InternalType;
rule.Type = ruleItem.Type;
_ruleRepository.Update(rule);
}
else
{
rule = _mapper.Map <Rule>(ruleItem);
rule.Id = 0;
rule.RuleTypeId = id;
rule.RuleId = maxRuleId++;
_ruleRepository.Add(rule);
if (targetRuleType.AllowedForAutopilot && !targetRuleType.IsCustom)
{
newRuleIds.Add(rule.RuleId);
}
}
}
_ruleRepository.SaveChanges();
// Delete rules only for custom rule types
if (deletedRuleIds.Any())
{
deletedRuleIds.ForEach(r => _ruleRepository.Delete(r.Id));
}
_ruleRepository.SaveChanges();
if (targetRuleType.AllowedForAutopilot && !targetRuleType.IsCustom)
{
UpdateAutopilotRulesRepository(targetRuleType.Id, newRuleIds, deletedRuleIds.Select(r => r.RuleId).ToList());
}
var ruleType = _ruleTypeRepository.Get(id);
return(Ok(Mappings.MapToRuleTypeModel(ruleType, _ruleRepository, _mapper)));
}
public void Delete(int id)
{
_ruleRepo.Delete(id);
_ruleRepo.SaveChanges();
}
public ActionResult Delete([FromBody] int id)
{
return(Ok(_repo.Delete(id)));
}
