public async Task <bool> SendMessageToServer(string subject, string message)
{
var token = await HttpContext.GetUserAccessTokenAsync();
var client = this._httpClientFactory.CreateClient("client");
client.SetBearerToken(token);
var apiServerUrl = _configuration.GetSection("SiteSettings:Products:FEConsole")
.GetValue <string>("feconsoleApiUrl");
var messageServerUrl = apiServerUrl.EndsWith("/") ? string.Format("{0}{1}", apiServerUrl, "api/SiteAdmin/SendMessage")
: string.Format("{0}{1}", apiServerUrl, "/api/SiteAdmin/SendMessage");
var sendData = new AppEventModel();
sendData.EventTitle = subject;
sendData.EventDetails = string.Format("{0}===>{1}",
HttpContext.GetLoginUserDisplayName(),
message);
sendData.EventLevel = AppEventModel.EnumEventLevel.Warning;
sendData.EventOwner = HttpContext.GetLoginUserEmail() ?? HttpContext.GetLoginUserDisplayName();
sendData.EventSource = AppEventModel.EventSourceEnum.Portal;
string content = JsonConvert.SerializeObject(sendData);
StringContent reqContent = new StringContent(content);
reqContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = await client.PostAsync(messageServerUrl, reqContent);
return(response.IsSuccessStatusCode);
}
private async Task SendMailMessage(AppEventModel message)
{
var config = this._configuration.GetSection("SiteSettings:MailConfig");
var mailServer = config.GetValue <String>("SMTPServer");
var mailPort = config.GetValue <int>("SMTPPort");
var mailSender = config.GetValue <String>("Sender");
var mailSenderPassword = config.GetValue <string>("SenderPassword");
var mailReceiver = config.GetValue <string>("Receiver");
bool useSSL = config.GetValue <bool>("UseSsl");
var mailMessage = new MimeMessage();
var sender = new MailboxAddress("Notifier", mailSender);
logger.LogInformation(mailServer);
logger.LogInformation(mailPort.ToString());
logger.LogInformation(mailSender);
logger.LogInformation(mailReceiver);
mailMessage.Sender = sender;
mailMessage.Subject = message.EventTitle;
mailMessage.From.Add(sender);
StringBuilder builder = new StringBuilder();
builder.AppendLine("<div>");
builder.AppendLine(string.Format("<h1>{0}</h1>", message.EventTitle));
builder.AppendLine(string.Format("<h2>{0}</h2>", message.EventOwner));
builder.AppendLine(string.Format("<p>{0}</p>", message.EventDetails));
builder.AppendLine("</div>");
mailMessage.To.Add(new MailboxAddress("Support", mailReceiver));
mailMessage.Body = new TextPart(TextFormat.Html)
{
Text = builder.ToString()
};
using (var mailClient = new MailKit.Net.Smtp.SmtpClient())
{
mailClient.MessageSent += (sender, args) => { logger.LogInformation("mail sent by :" + sender); };
if (useSSL)
{
mailClient.ServerCertificateValidationCallback = (s, c, h, e) => true;
await mailClient.ConnectAsync(mailServer, mailPort, SecureSocketOptions.Auto);
}
else
{
await mailClient.ConnectAsync(mailServer, mailPort, SecureSocketOptions.None);
}
await mailClient.AuthenticateAsync(mailSender, mailSenderPassword);
await mailClient.SendAsync(mailMessage);
await mailClient.DisconnectAsync(true);
}
}
public async Task <bool> SendMessage(AppEventModel message)
{
try
{
await SendMailMessage(message);
}
catch (System.Exception)
{
message.EventOwner = this._configuration.GetValue <string>("SiteSettings:SuperAdmin");
await LogEvent(message);
}
return(true);
}
public async Task <ActionResult> Error()
{
var exceptionHandlerPathFeature =
HttpContext.Features.Get <IExceptionHandlerPathFeature>();
if (!string.IsNullOrEmpty(exceptionHandlerPathFeature?.Error.Message))
{
logger.LogError(exceptionHandlerPathFeature?.Error.Message);
AppEventModel errEvent = new AppEventModel();
errEvent.EventTitle = _sharedResource["ERROR_SERVER_ERROR"];
errEvent.EventDetails = _sharedResource["ERROR_SERVER_ERROR_BODY", exceptionHandlerPathFeature?.Error.Message];
errEvent.EventOwner = HttpContext.GetLoginUser();
errEvent.EventLevel = AppEventModel.EnumEventLevel.Error;
var client = _httpClientFactory.CreateClient("client");
var baseUrl = HttpContext.WebApiBaseUrl();
await client.LogEvent(baseUrl, errEvent);
}
return(View());
}
public async Task <FEGeneralError> Get()
{
FEGeneralError error = new FEGeneralError();
var exceptionHandlerPathFeature =
HttpContext.Features.Get <IExceptionHandlerPathFeature>();
error.ErrorCode = StatusCodes.Status500InternalServerError;
error.ErrorDescription = exceptionHandlerPathFeature?.Error.Message;
if (!string.IsNullOrEmpty(exceptionHandlerPathFeature?.Error.Message))
{
AppEventModel errEvent = new AppEventModel();
errEvent.EventTitle = "Application Error Happened";
errEvent.EventDetails = exceptionHandlerPathFeature?.Error.Message;
errEvent.EventOwner = await GetLoginUser();
errEvent.EventLevel = AppEventModel.EnumEventLevel.Error;
errEvent.EventDateTime = DateTime.Now;
await LogAppEvent(_objectService, errEvent);
}
return(error);
}
public async Task <int> LogEvent(AppEventModel logEvent)
{
int objId = await LogAppEvent(objectService, logEvent);
return(objId);
}
protected async Task <int> LogAppEvent(IObjectService objectService, AppEventModel logEvent)
{
string owner = logEvent.EventSource == AppEventModel.EventSourceEnum.Portal ? "portal"
: await GetLoginUser();
ServiceObject svObject = new ServiceObject();
svObject.ObjectName = "System Event";
svObject.ObjectOwner = owner;
svObject.OnlyUpdateProperties = false;
svObject.UpdatedBy = owner;
svObject.CreatedBy = owner;
svObject.ObjectDefinitionId = objectService
.GetObjectDefinitionByName("AppEvent")
.ObjectDefinitionID;
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventTitle",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.String,
Value = logEvent.EventTitle
}
});
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventDetails",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.String,
Value = logEvent.EventDetails
}
});
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventDateTime",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.Datetime,
Value = DateTime.Now
}
});
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventLevel",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.Integer,
Value = (int)logEvent.EventLevel
}
});
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventOwner",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.String,
Value = owner
}
});
svObject.Properties.Add(new ObjectKeyValuePair()
{
KeyName = "eventSource",
Value = new PrimeObjectField()
{
PrimeDataType = PrimeFieldDataType.Integer,
Value = (int)logEvent.EventSource
}
});
int objId = objectService.CreateORUpdateGeneralObject(svObject);
return(objId);
}
public static async Task LogEvent(this HttpClient httpClient, string apiBaseUri, AppEventModel appEvent)
{
string requestBody = JsonConvert.SerializeObject(appEvent);
var stringContent = new StringContent(requestBody);
httpClient.PrepareRequestDefaultHeader(stringContent.Headers);
var response = await httpClient.PostAsync(string.Format("{0}/{1}", apiBaseUri, "api/SiteAdmin/LogEvent"),
stringContent);
}
