public async Task <Response> Create(CreateLogRequest request)
{
try
{
// If user role equals MANAGER, use id from request body,
// otherwise, use logged user id
int userId = _userService.GetLoggedUserId();
if (_userService.IsLoggedUserManager() && request.UserId.HasValue)
{
userId = request.UserId.Value;
}
var log = MapCreateLogRequestToLog(userId, request);
_repository.Add(log);
if (await _repository.SaveChangesAsync())
{
log = await _repository.GetById(log.Id);
var response = _mapper.Map <LogResponse>(log);
return(OkResponse(null, response));
}
return(BadRequestResponse("Erro desconhecido"));
}
catch (Exception ex)
{
return(BadRequestResponse(ex.Message));
}
}
private static async Task <string> CreateLog(LoggingManagementClient client, string logGroup, string logDisplayName)
{
CreateLogRequest createLogRequest = new CreateLogRequest
{
LogGroupId = logGroup,
// Create a createLogDetails to pass to Create Log Request
CreateLogDetails = new CreateLogDetails
{
DisplayName = logDisplayName,
LogType = CreateLogDetails.LogTypeEnum.Custom
}
};
// Pass createLogRequest to client to create the log
logger.Info($"Creating Log {logDisplayName}");
logger.Info("=============");
CreateLogResponse createLogResponse = await client.CreateLog(createLogRequest);
string workRequestId = createLogResponse.OpcWorkRequestId;
logger.Info($"CreateLog work request ID is {workRequestId}");
GetWorkRequestResponse workRequestResponse = WaitForWorkRequestFinished(client, workRequestId);
string logId = GetLogId(workRequestResponse);
logger.Info($"Created Log: {logDisplayName} under Log Group: {logGroup} with Log OCID:{logId}");
return(logId);
}
public Response CreateLog(CreateLogRequest request)
{
try
{
var retval = new Response();
string logFilePath = @"C:\Logs\Log-" + System.DateTime.Today.ToString("MM-dd-yyyy") + " " + System.DateTime.Now.ToString("HH-mm-ss") + "." + "txt";
FileInfo logFileInfo = new FileInfo(logFilePath);
DirectoryInfo logDirInfo = new DirectoryInfo(logFileInfo.DirectoryName);
if (!logDirInfo.Exists)
{
logDirInfo.Create();
}
using (FileStream fileStream = new FileStream(logFilePath, FileMode.Append))
{
using (StreamWriter log = new StreamWriter(fileStream))
{
log.WriteLine(request.LogData);
retval = new CreateLogResponsesOK();
}
}
return(retval);
}
catch (Exception ex)
{
return(new AppResponseError(ex.Message));
}
}
public async Task <IActionResult> Post(CreateLogRequest request)
{
var mapped = request.MapToCoreRequest(_mapper);
var response = await _logService.Create(mapped);
return(StatusCode(response.Code, response));
}
private Log MapCreateLogRequestToLog(int userId, CreateLogRequest request)
{
var log = _mapper.Map <Log>(request);
log.UserId = userId;
log.Archived = false;
log.CreatedAt = DateTime.Now;
return(log);
}
public async Task <ActionResult> CreateLogMessages([FromBody] CreateLogRequest request)
{
if (request == null || request.LogRequest == null || request.LogRequest.Count() < 1)
{
return(BadRequest());
}
string result = await _handler.CallAirTableCreateLogs(request);
if (string.IsNullOrEmpty(result))
{
return(NotFound());
}
var createdLogs = _handler.ParseToPostReponse(result);
return(Ok(createdLogs));
}
public async Task <IActionResult> Post([FromRoute] Request meta, [FromBody] CreateLogRequest request)
{
IActionResult result = null;
var id = await Server.Save(new LogEntry()
{
Id = Guid.Empty,
Timestamp = request.Timestamp,
Application = meta.Application,
Source = request.Source,
Event = request.Event,
Level = request.Level,
Message = request.Message,
Properties = request.Properties,
Tags = request.Tags
});
result = Factory.CreateSuccessResponse(id);
return(result);
}
/// <summary>
/// Method to invoke AirTable POST endpoint
/// </summary>
/// <param name="request">Create log request</param>
/// <returns></returns>
public async Task <string> CallAirTableCreateLogs(CreateLogRequest request)
{
// Read properties from appsettings.json
string url = _configuration["AirTablePostUri"];
string apiKey = _configuration["AirTableApiKey"];
// Logic to convert given request to AirTable request
var airTableRequest = new JObject();
var fields = new JArray();
foreach (var log in request.LogRequest)
{
var fieldItem = new JObject();
fieldItem.Add("id", log.Id);
fieldItem.Add("Summary", log.Title);
fieldItem.Add("Message", log.Text);
fieldItem.Add("receivedAt", log.ReceivedAt);
var fieldObject = new JObject();
fieldObject.Add("fields", fieldItem);
fields.Add(fieldObject);
}
airTableRequest.Add("records", fields);
HttpResponseMessage response = null;
using (var httpClient = new HttpClient())
{
// Add API key as bearer in authorization header
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
string jsonRequest = JsonConvert.SerializeObject(airTableRequest);
var stringContent = new StringContent(jsonRequest, UnicodeEncoding.UTF8, "application/json");
// Invoke AirTable POST endpoint to create log messages
response = await httpClient.PostAsync(url, stringContent);
}
return(await response?.Content.ReadAsStringAsync());
}
public async Task <IActionResult> Post([FromBody] CreateLogRequest request)
{
if (request == null ||
request.VariantId == 0 ||
string.IsNullOrEmpty(request.Action))
{
return(PreconditionFailed());
}
var email = _contextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.Email);
if (string.IsNullOrEmpty(email))
{
return(BadRequest());
}
var student = await _db.Students.SingleOrDefaultAsync(s => s.Email == email);
if (student == null)
{
return(BadRequest());
}
var logEntry = new TaskVariantLog
{
Action = request.Action,
DateTime = DateTime.Now,
StudentId = student.Id,
VariantId = request.VariantId,
Penalty = request.Penalty ?? 0
};
await _db.TaskVariantLogs.AddAsync(logEntry);
await _db.SaveChangesAsync();
return(Created(logEntry));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateLogRequest request;
try
{
request = new CreateLogRequest
{
LogGroupId = LogGroupId,
CreateLogDetails = CreateLogDetails,
OpcRetryToken = OpcRetryToken,
OpcRequestId = OpcRequestId
};
response = client.CreateLog(request).GetAwaiter().GetResult();
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public Response CreateLog(CreateLogRequest request)
{
try
{
var date = System.DateTime.Today.ToString("yyyy-MM-dd");
var logName = System.DateTime.Today.ToString("MM-dd-yyyy") + " " + System.DateTime.Now.ToString("HH-mm-ss") + "." + "txt";
var ds = _dal.CreateLog(request.LogData, date, logName);
var tbl = ds.Tables[0];
var retval = new Response();
if (tbl.Rows.Count == 1)
{
if (request.LogData == (string)tbl.Rows[0][0])
{
retval = new CreateLogResponsesOK();
}
}
return(retval);
}
catch (Exception ex)
{
return(new AppResponseError(ex.Message));
}
}
public Response CreateLog([FromBody] CreateLogRequest request)
{
var serviceCreated = _service.Create(request.LogType);
return(serviceCreated.CreateLog(request));
}
public static Core.Dto.Requests.CreateLogRequest MapToCoreRequest(
this CreateLogRequest request,
IMapper mapper)
{
return(mapper.Map <Core.Dto.Requests.CreateLogRequest>(request));
}
