public async Task <ActionResult> Index(LogRequestModel model)
{
if (ModelState.IsValid)
{
var result = new LogViewModel();
try
{
//check if session exists
var access_token = HttpContext.Session[model.application_id];
if (access_token == null)
{
throw new Exception("Please authenticate before using the logging.");
}
var success = await service.Log(access_token.ToString(), model);
result.Result = success;
TempData["model"] = result;
return(RedirectToAction("Result"));
}
catch (Exception e)
{
result.Error = e.Message;
TempData["model"] = result;
return(RedirectToAction("Result"));
}
}
return(View(model));
}
public async Task <IActionResult> GetByType(LogRequestModel request)
{
try
{
if (request == null)
{
return(BadRequest("В запросе отсутствуют данные."));
}
_logger.LogInformation("Request: " + request.LogType);
var logDtoModel = await _logService.GetByType(request.LogType);
var logResponseModel = _mapper.Map <LogResponseModel>(logDtoModel);
_logger.LogInformation("Response: response is " + string.IsNullOrEmpty(logResponseModel.Logs));
return(Ok(logResponseModel));
}
catch (Exception ex)
{
_logger.LogError("Request Exception: " + ex);
return(BadRequest());
}
}
/// <summary>
/// Maps the LogRequestModel object to Log object.
/// </summary>
/// <param name="model">The LogRequestModel object to map.</param>
/// <returns>Mapped Log object</returns>
public static Log LogRequestModelToLog(LogRequestModel model)
{
return(new Log
{
application_id = model.application_id,
logger = model.logger,
level = model.level,
message = model.message
});
}
public async Task <IHttpActionResult> Log([FromBody] LogRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var log = Mapper.LogRequestModelToLog(model);
int result = await applicationHandler.LogAsync(log);
var response = new LogResponseModel(result > 0);//success or failure of the save to database operation
return(Ok(response));
}
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
if (IsEnabled)
{
Guid requestId = Guid.NewGuid();
context.HttpContext.Response.Headers.Add("requestId", requestId.ToString());
var executedContext = await next();
var service = (BudgetService)context.HttpContext.RequestServices.GetService(typeof(BudgetService));
LogRequestModel lrm = new LogRequestModel
{
RequestId = requestId,
Request = context.HttpContext.Request.Path.ToString(), // request path? I don't know much about HTTP headers
Response = context.HttpContext.Response.StatusCode.ToString() // response code
};
service.CreateAccessLog(lrm);
}
}
public async Task <IHttpActionResult> PostWarning(LogRequestModel model)
{
await _logger.LogWarningAsync(model.Message);
return(Ok());
}
public async Task <IHttpActionResult> PostInfo(LogRequestModel model)
{
await _logger.LogInformationAsync(model.Message);
return(Ok());
}
public void LogError([FromBody] LogRequestModel model)
{
_logger.LogError($"{model.ClientId}: {model.Message}\nPath: {model.Path}\n{model.StackTrace}");
}
public static LogEntryModel Map(ILogEntry logEntry)
{
var logRequestModel = new LogRequestModel
{
DateTime = logEntry.RequestMessage.DateTime,
ClientIP = logEntry.RequestMessage.ClientIP,
Path = logEntry.RequestMessage.Path,
AbsolutePath = logEntry.RequestMessage.AbsolutePath,
Url = logEntry.RequestMessage.Url,
AbsoluteUrl = logEntry.RequestMessage.AbsoluteUrl,
ProxyUrl = logEntry.RequestMessage.ProxyUrl,
Query = logEntry.RequestMessage.Query,
Method = logEntry.RequestMessage.Method,
Headers = logEntry.RequestMessage.Headers,
Cookies = logEntry.RequestMessage.Cookies
};
if (logEntry.RequestMessage.BodyData != null)
{
logRequestModel.DetectedBodyType = logEntry.RequestMessage.BodyData.DetectedBodyType.ToString();
logRequestModel.DetectedBodyTypeFromContentType = logEntry.RequestMessage.BodyData.DetectedBodyTypeFromContentType.ToString();
switch (logEntry.RequestMessage.BodyData.DetectedBodyType)
{
case BodyType.String:
logRequestModel.Body = logEntry.RequestMessage.BodyData.BodyAsString;
break;
case BodyType.Json:
logRequestModel.Body = logEntry.RequestMessage.BodyData.BodyAsString; // In case of Json, do also save the Body as string (backwards compatible)
logRequestModel.BodyAsJson = logEntry.RequestMessage.BodyData.BodyAsJson;
break;
case BodyType.Bytes:
logRequestModel.BodyAsBytes = logEntry.RequestMessage.BodyData.BodyAsBytes;
break;
}
logRequestModel.BodyEncoding = logEntry.RequestMessage.BodyData.Encoding != null
? new EncodingModel
{
EncodingName = logEntry.RequestMessage.BodyData.Encoding.EncodingName,
CodePage = logEntry.RequestMessage.BodyData.Encoding.CodePage,
WebName = logEntry.RequestMessage.BodyData.Encoding.WebName
}
: null;
}
var logResponseModel = new LogResponseModel
{
StatusCode = logEntry.ResponseMessage.StatusCode,
Headers = logEntry.ResponseMessage.Headers
};
if (logEntry.ResponseMessage.FaultType != FaultType.NONE)
{
logResponseModel.FaultType = logEntry.ResponseMessage.FaultType.ToString();
logResponseModel.FaultPercentage = logEntry.ResponseMessage.FaultPercentage;
}
if (logEntry.ResponseMessage.BodyData != null)
{
logResponseModel.BodyOriginal = logEntry.ResponseMessage.BodyOriginal;
logResponseModel.BodyDestination = logEntry.ResponseMessage.BodyDestination;
logResponseModel.DetectedBodyType = logEntry.ResponseMessage.BodyData.DetectedBodyType;
logResponseModel.DetectedBodyTypeFromContentType = logEntry.ResponseMessage.BodyData.DetectedBodyTypeFromContentType;
switch (logEntry.ResponseMessage.BodyData.DetectedBodyType)
{
case BodyType.String:
logResponseModel.Body = logEntry.ResponseMessage.BodyData.BodyAsString;
break;
case BodyType.Json:
logResponseModel.BodyAsJson = logEntry.ResponseMessage.BodyData.BodyAsJson;
break;
case BodyType.Bytes:
logResponseModel.BodyAsBytes = logEntry.ResponseMessage.BodyData.BodyAsBytes;
break;
case BodyType.File:
logResponseModel.BodyAsFile = logEntry.ResponseMessage.BodyData.BodyAsFile;
logResponseModel.BodyAsFileIsCached = logEntry.ResponseMessage.BodyData.BodyAsFileIsCached;
break;
}
logResponseModel.BodyEncoding = logEntry.ResponseMessage.BodyData.Encoding != null
? new EncodingModel
{
EncodingName = logEntry.ResponseMessage.BodyData.Encoding.EncodingName,
CodePage = logEntry.ResponseMessage.BodyData.Encoding.CodePage,
WebName = logEntry.ResponseMessage.BodyData.Encoding.WebName
}
: null;
}
return(new LogEntryModel
{
Guid = logEntry.Guid,
Request = logRequestModel,
Response = logResponseModel,
MappingGuid = logEntry.MappingGuid,
MappingTitle = logEntry.MappingTitle,
RequestMatchResult = Map(logEntry.RequestMatchResult),
PartialMappingGuid = logEntry.PartialMappingGuid,
PartialMappingTitle = logEntry.PartialMappingTitle,
PartialRequestMatchResult = Map(logEntry.PartialMatchResult)
});
}
