public Task <List <LogModel> > GetAllLogs(LogFilterRequest filter)
{
return(logsDbSet
.Where(CreateLogFilter(filter))
.OrderBy(log => log.Date)
.Skip((filter.PageNumber - 1) * filter.ItemsPerPage)
.Take(filter.ItemsPerPage)
.ToListAsync());
}
private Func <LogModel, string> CreateLogGroupping(LogFilterRequest filter)
{
if (filter.IsHostRequest)
{
return(log => log.HostName);
}
return(log => log.Route);
}
public async Task <IList <TopModel> > GetpTopByField(LogFilterRequest filter)
{
var top = filter.Top ?? 10;
var grouppedLogs = await logsDbSet
.Where(CreateLogFilter(filter))
.ToListAsync();
return(grouppedLogs
.GroupBy(CreateLogGroupping(filter))
.Select(GetTopModel)
.OrderByDescending(group => group.Count)
.Take(top)
.ToList());
}
public async Task GetTopOneLog()
{
var filter = new LogFilterRequest
{
Top = 1
};
var expectedResult = new LogModel()
{
};
var result = await logReadRepository.GetAllLogs(filter);
Assert.AreEqual(expectedResult, result);
}
public async Task <ServiceResponse <List <EwsLog> > > FindLogsByConditions(LogFilterRequest request)
{
try
{
var expresion = LogExpression(request);
var regionResource = await _logRepository.FindByConditions(expresion);
return(new ServiceResponse <List <EwsLog> >(regionResource));
}
catch (Exception ex)
{
Log.Error("An Error Occured While fetching the requested Logs Resource. {@ex}", ex);
return(new ServiceResponse <List <EwsLog> >($"An Error Occured While fetching the requested Logs Resource. {ex.Message}"));
}
}
private Expression <Func <EwsLog, bool> > LogExpression(LogFilterRequest model)
{
var predicate = UtilityService.True <EwsLog>();
//predicate = UtilityService.And(predicate, x => x.Level != EntityStatus.Disabled);
if (model.Level != null)
{
predicate = UtilityService.And(predicate, x => x.Level.Contains(model.Level));
}
if (model.LogEvent != null)
{
predicate = UtilityService.And(predicate, x => x.LogEvent.Contains(model.LogEvent));
}
if (model.Message != null)
{
predicate = UtilityService.And(predicate, x => x.Message.Contains(model.Message));
}
if (model.MessageTemplate != null)
{
predicate = UtilityService.And(predicate, x => x.MessageTemplate.Contains(model.MessageTemplate));
}
if (model.StartDate != null)
{
predicate = UtilityService.And(predicate, x => x.TimeStamp >= model.StartDate);
}
if (model.EndDate != null)
{
predicate = UtilityService.And(predicate, x => x.TimeStamp <= model.EndDate);
}
if (model.Exception != null)
{
predicate = UtilityService.And(predicate, x => x.Exception.Contains(model.Exception));
}
if (model.LogEvent != null)
{
predicate = UtilityService.And(predicate, x => x.Exception.Contains(model.LogEvent));
}
return(predicate);
}
public async Task <ActionResult <LogReportResponse> > GetLogsWithFilter([FromBody] LogFilterRequest filterRequest)
{
//For performance reasons we don't use Automapper here.
var logs = (await _logQueryService.GetLogs(
new LoggingDal.PaginationParams
{
Offset = filterRequest.PaginationParams.Offset,
PageNumber = filterRequest.PaginationParams.PageNumber
},
new LoggingDal.FilterParams
{
GroupKey = filterRequest.GroupKey,
JobKey = filterRequest.JobKey,
Description = filterRequest.Description,
FromDate = filterRequest.FromDate,
ToDate = filterRequest.ToDate,
Severity = filterRequest.Severity,
IsAscending = filterRequest.IsAscending
}));
return(Ok(
new LogReportResponse
{
TotalNumber = logs.totalNumber,
Logs = logs.logs.Select(l => new Log
{
Id = l.Id,
GroupKey = l.GroupKey,
JobKey = l.JobKey,
JobDescription = l.JobDescription,
Message = l.Msg,
Severity = l.Severity,
TimeStamp = l.Timestamp
})
}));
}
private Expression <Func <LogModel, bool> > CreateLogFilter(LogFilterRequest filter)
{
return(log => CreationFromDateFilter(filter.FromDate, log.Date) &&
CreationToDateFilter(filter.ToDate, log.Date));
}
public Task <long> GetAllLogsCount(LogFilterRequest filter)
{
return(logsDbSet
.Where(CreateLogFilter(filter))
.LongCountAsync());
}
public async Task <IList <TopModel> > GetTopRecords([FromBody] LogFilterRequest filter)
{
return(await logReadRepository.GetpTopByField(filter));
}
public async Task <List <LogModel> > GetAllLogs([FromBody] LogFilterRequest filter)
{
return(await logReadRepository.GetAllLogs(filter));
}
public async Task <long> GetAllLogsCount([FromBody] LogFilterRequest filter)
{
return(await logReadRepository.GetAllLogsCount(filter));
}
