public async Task <int> Create(SeverityRule model)
{
var severityRuleDto = model.ToDomainModel();
var generalRuleId = severityRuleDto.GeneralRuleId;
if (!DoesGeneralRuleExists(generalRuleId))
{
if (model.GeneralRule == null)
{
throw new ArgumentException();
}
generalRuleId = await _generalRuleRepository.Create(model.GeneralRule);
}
severityRuleDto.GeneralRuleId = generalRuleId;
var entity = await _db.SeverityLevelRule.AddAsync(severityRuleDto);
await _db.SaveChangesAsync();
entity.State = EntityState.Detached;
return(entity.Entity.SeverityLevelRuleId);
}
public async Task <SeverityRule> Edit(SeverityRule model)
{
var isUpdated = await _severityRuleRepository.Update(model);
if (isUpdated)
{
return(await _severityRuleRepository.Read(model.Id));
}
throw new Exception($"Failed to update message rule {model.Id}");
}
public static SeverityLevelRule ToDomainModel(this SeverityRule model)
{
if (model == null)
{
return(null);
}
var dto = new SeverityLevelRule
{
SeverityLevelRuleId = model.Id, GeneralRuleId = model.GeneralRuleId, Debug = model.Debug.ToString(),
Error = model.Error.ToString(),
Fatal = model.Fatal.ToString(), Info = model.Info.ToString(), Trace = model.Trace.ToString(),
Warning = model.Warning.ToString()
};
return(dto);
}
public SeverityLevel ParseSeverityLevel(string line, SeverityRule rule)
{
line = ApplyAnchors(line, rule.GeneralRule.StartAnchor, rule.GeneralRule.EndAnchor);
var parsedValue = rule.GeneralRule.Matcher.Match(line);
if (!parsedValue.Success)
{
throw new ArgumentException(
$"Could not apply matcher '{rule.GeneralRule.Matcher}' to line '{line}' to extract severity level");
}
if (rule.Fatal.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Fatal);
}
if (rule.Error.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Error);
}
if (rule.Warning.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Warning);
}
if (rule.Info.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Info);
}
if (rule.Trace.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Trace);
}
if (rule.Debug.IsMatch(parsedValue.Value))
{
return(SeverityLevel.Debug);
}
throw new ArgumentException($"Parsed value did not match any defined level: parsed '{parsedValue.Value}'");
}
public NormalizedLog ParseAll(string line, DateTimeRule dateTimeRule, SeverityRule severityRule,
MessageRule messageRule, IEnumerable <GeneralRule> customAttributeRules)
{
var dateTime = ParseDateTime(line, dateTimeRule);
var severity = ParseSeverityLevel(line, severityRule);
var message = ParseMessage(line, messageRule);
var customAttributes = new List <CustomAttributeValue>();
foreach (var customAttributeRule in customAttributeRules)
{
var result = ParseCustomAttribute(line, customAttributeRule);
customAttributes.Add(new CustomAttributeValue
{
GeneralRule = customAttributeRule, Id = 0, Value = result,
CustomAttributeRuleId = customAttributeRule.Id
});
}
// TODO check this
return(new NormalizedLog(dateTime, severity, message, 0, 0, 0, customAttributes.ToArray()));
}
public async Task <bool> Update(SeverityRule model)
{
try
{
var dto = model.ToDomainModel();
if (model.GeneralRule != null)
{
await _generalRuleRepository.Update(model.GeneralRule);
}
_db.SeverityLevelRule.Update(dto);
await _db.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <SeverityRule> Create(SeverityRule model)
{
var createdId = await _severityRuleRepository.Create(model);
return(await _severityRuleRepository.Read(createdId));
}
