/// <summary>
/// Start windows service
/// </summary>
public void Start()
{
try
{
ProcessTask = Task.Run(() =>
{
try
{
//Build config for webserver
var config = new ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddEnvironmentVariables()
.AddCommandLine(Arguments)
.AddJsonFile("appsettings.json", optional: false)
.Build();
if (RunAsService)
{
var certificatePathSection = config.GetSection("Kestrel:EndPoints:Https:Certificate:Path");
var certificatePasswordSection = config.GetSection("Kestrel:EndPoints:Https:Certificate:Password");
if (certificatePathSection.Value == null)
{
var appdata = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var certFolder = Path.Combine(appdata, "AnalyticsGate", "AGCR", "certificates");
var passKey = Path.Combine(certFolder, "AGRRoot.key");
var passDat = Path.Combine(certFolder, "AGRRoot.keypas");
var crypter = new TextCrypter(passKey);
var password = crypter.DecryptText(File.ReadAllText(passDat));
certificatePathSection.Value = Path.Combine(certFolder, "AGRRoot.pfx");
certificatePasswordSection.Value = password;
}
}
//Start the web server
CreateHostBuilder(Arguments)
.UseKestrel()
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
})
.UseNLog()
.Build()
.Run();
}
catch (Exception ex)
{
logger.Error(ex);
}
}, cts.Token);
}
catch (Exception ex)
{
throw new Exception("Web service startup failed.", ex);
}
}
private SerConfig CreateEngineConfig(QlikRequest request, SessionInfo session)
{
logger.Debug($"Resolve script '{request.JsonScript}' for engine config...");
var jsonStr = request.JsonScript;
//Make full JSON for Engine
logger.Debug("Auto replacement to normal json structure...");
if (!jsonStr.ToLowerInvariant().Contains("\"reports\":"))
{
jsonStr = $"\"reports\":[{jsonStr}]";
}
if (!jsonStr.ToLowerInvariant().Contains("\"tasks\":"))
{
jsonStr = $"\"tasks\":[{{{jsonStr}}}]";
}
if (!jsonStr.Trim().StartsWith("{"))
{
jsonStr = $"{{{jsonStr}";
}
if (!jsonStr.Trim().EndsWith("}"))
{
jsonStr = $"{jsonStr}}}";
}
logger.Debug("Search for connections for the engine config...");
dynamic serJsonConfig = JObject.Parse(jsonStr);
var tasks = serJsonConfig?.tasks ?? new JArray();
foreach (var task in tasks)
{
var reports = task?.reports ?? new JArray();
foreach (var report in reports)
{
var userConnections = new JArray();
JToken connections = report?.connections;
if (connections.Type == JTokenType.Object)
{
userConnections.Add(report?.connections);
}
else if (connections.Type == JTokenType.Array)
{
userConnections = report?.connections;
}
else
{
logger.Error($"No valid connection type '{connections.Type}'.");
}
var newUserConnections = new List <JToken>();
for (int i = 0; i < userConnections.Count; i++)
{
var mergeConnection = userConnections[i] as JObject;
var credType = Options.Config?.Connection?.Credentials?.Type ?? QlikCredentialType.JWT;
var connectorConnection = JObject.FromObject(CreateConnection(credType, session));
connectorConnection.Merge(mergeConnection, new JsonMergeSettings()
{
MergeNullValueHandling = MergeNullValueHandling.Ignore
});
newUserConnections.Add(connectorConnection);
}
report.connections = new JArray(newUserConnections);
if (report.distribute is JObject distribute)
{
var children = distribute?.Children().Children()?.ToList() ?? new List <JToken>();
foreach (dynamic child in children)
{
var connection = child.connections ?? null;
if (connection == null)
{
child.connections = new JArray(newUserConnections);
}
else if (connection?.ToString() == "@CONFIGCONNECTION@")
{
child.connections = new JArray(newUserConnections);
}
var childProp = (child as JObject).Parent as JProperty;
if (childProp?.Name?.StartsWith("hub") ?? false)
{
if (child?.owner == null)
{
child.owner = session.User.ToString();
}
}
else if (childProp?.Name?.StartsWith("mail") ?? false)
{
if (child?.mailServer != null)
{
if (child?.mailServer?.privateKey == null)
{
child.mailServer.privateKey = Options?.Config?.Connection?.Credentials?.PrivateKey;
}
}
}
}
}
var privateKey = Options.Config?.Connection?.Credentials?.PrivateKey ?? null;
if (!String.IsNullOrEmpty(privateKey))
{
// For file access
lock (threadObject)
{
var path = HelperUtilities.GetFullPathFromApp(privateKey);
var crypter = new TextCrypter(path);
var value = report?.template?.outputPassword ?? null;
if (value == null)
{
value = report?.template?.outputpassword ?? null;
}
if (value != null)
{
string password = value.ToString();
if (value.Type == JTokenType.Boolean)
{
password = password.ToLowerInvariant();
}
bool useBase64Password = report?.template?.useBase64Password ?? false;
if (useBase64Password == true)
{
report.template.outputPassword = crypter.DecryptText(password);
}
else
{
report.template.outputPassword = password;
}
}
}
}
}
}
//Resolve @PROPERTYNAME@ and @("
var jsonResolver = new JsonConfigResolver(serJsonConfig.ToString());
var jsonResult = jsonResolver.Resolve();
var serConfiguration = JsonConvert.DeserializeObject <SerConfig>(jsonResult);
return(serConfiguration);
}
public void SendMails()
{
try
{
logger.Debug("Summarized mails...");
foreach (var mailcache in MailCaches)
{
var summarizedMail = GetMailFromSummarizedMailList(mailcache.Settings);
if (summarizedMail == null)
{
logger.Debug("Create new mail for summarized mail list...");
var mailTo = mailcache.Settings?.To?.Replace(";", ",")?.TrimEnd(',') ?? "No mail recipient was specified.";
var mailFrom = mailcache.Settings?.MailServer?.From ?? "No sender was specified.";
summarizedMail = new MailMessage(mailFrom, mailTo)
{
BodyEncoding = Encoding.UTF8,
SubjectEncoding = Encoding.UTF8,
Subject = mailcache.Settings?.Subject?.Trim() ?? "No subject was specified.",
};
var ccAddresses = mailcache.Settings?.Cc?.Replace(";", ",")?.TrimEnd(',');
if (!String.IsNullOrEmpty(ccAddresses))
{
summarizedMail.CC.Add(ccAddresses);
}
var bccAddresses = mailcache.Settings?.Bcc?.Replace(";", ",")?.TrimEnd(',');
if (!String.IsNullOrEmpty(bccAddresses))
{
summarizedMail.Bcc.Add(bccAddresses);
}
var msgBody = mailcache.Settings?.Message?.Trim() ?? String.Empty;
switch (mailcache.Settings?.MailType ?? EMailType.TEXT)
{
case EMailType.TEXT:
msgBody = msgBody.Replace("{n}", Environment.NewLine);
break;
case EMailType.HTML:
summarizedMail.IsBodyHtml = true;
break;
case EMailType.MARKDOWN:
summarizedMail.IsBodyHtml = true;
msgBody = Markdown.ToHtml(msgBody);
break;
default:
throw new Exception($"Unknown mail type {mailcache.Settings?.MailType}.");
}
msgBody = msgBody.Trim();
logger.Debug($"Set mail body '{msgBody}'...");
summarizedMail.Body = msgBody;
if (mailcache.Settings.SendAttachment)
{
logger.Debug($"Attachment report files...");
AddReportstoMail(summarizedMail, mailcache.Report);
}
else
{
logger.Debug($"Use no mail attachment...");
}
SummarizedMails.Add(summarizedMail);
}
else
{
logger.Debug("Duplicate Mail settings was found in summarized mail list...");
if (mailcache.Settings.SendAttachment)
{
logger.Debug($"Attachment report files...");
AddReportstoMail(summarizedMail, mailcache.Report);
}
else
{
logger.Debug($"Use no mail attachment...");
}
}
}
var mailServers = MailCaches.Select(c => c.Settings).Select(s => s.MailServer).GroupBy(s => s.Host).Select(s => s.First()).ToList();
logger.Debug($"Send {SummarizedMails.Count} Mails over {MailCaches.Count} mail servers...");
foreach (var mailServer in mailServers)
{
var mailResult = new MailResult();
try
{
foreach (var summarizedMail in SummarizedMails)
{
using var client = new SmtpClient(mailServer.Host, mailServer.Port);
var priateKeyPath = HelperUtilities.GetFullPathFromApp(mailServer.PrivateKey);
if (!File.Exists(priateKeyPath))
{
logger.Debug("No private key path found...");
}
if (!String.IsNullOrEmpty(mailServer.Username) && !String.IsNullOrEmpty(mailServer.Password))
{
logger.Debug($"Set mail server credential for user '{mailServer.Username}'...");
var password = mailServer.Password;
if (mailServer.UseBase64Password && File.Exists(priateKeyPath))
{
logger.Debug($"Use private key path {priateKeyPath}...");
var textCrypter = new TextCrypter(priateKeyPath);
password = textCrypter.DecryptText(password);
}
client.Credentials = new NetworkCredential(mailServer.Username, password);
}
else
{
logger.Debug($"No mail server credential found...");
}
if (mailServer.UseSsl)
{
logger.Debug($"Use SSL for mail sending...");
client.EnableSsl = true;
}
if (mailServer.UseCertificate && File.Exists(priateKeyPath))
{
var certifcateFolder = Path.GetDirectoryName(priateKeyPath);
logger.Info($"Search for email certificates with name 'mailcert.*' in folder '{certifcateFolder}'...");
var certFiles = Directory.GetFiles(certifcateFolder, "mailcert.*", SearchOption.TopDirectoryOnly);
foreach (var certFile in certFiles)
{
logger.Debug($"Load certificate '{certFile}'.");
var x509File = new X509Certificate2(certFile);
logger.Debug($"Add certificate '{certFile}'.");
client.ClientCertificates.Add(x509File);
}
}
if (summarizedMail.To.Count > 0)
{
var delay = 0;
if (mailServer.SendDelay > 0)
{
delay = mailServer.SendDelay * 1000;
logger.Debug($"Wait {delay} milliseconds for the mail to be sent...");
}
Task.Delay(delay).ContinueWith(r =>
{
logger.Debug("Send mail package...");
client.Send(summarizedMail);
mailResult.Message = "The mail was sent successfully.";
mailResult.Success = true;
mailResult.TaskName = JobResult.TaskName;
mailResult.ReportState = GetFormatedState();
}).Wait();
}
else
{
mailResult.Message = "Mail without mail Address could not be sent.";
logger.Error(mailResult.Message);
mailResult.Success = false;
mailResult.TaskName = JobResult.TaskName;
mailResult.ReportState = "ERROR";
JobResult.Exception = ReportException.GetException(mailResult.Message);
JobResult.Status = TaskStatusInfo.ERROR;
}
client.Dispose();
Results.Add(mailResult);
}
}
catch (Exception ex)
{
logger.Error(ex, $"The delivery via 'Mail' failed with server '{mailServer.Host}'.");
JobResult.Exception = ReportException.GetException(ex);
JobResult.Status = TaskStatusInfo.ERROR;
mailResult.Success = false;
mailResult.ReportState = "ERROR";
mailResult.TaskName = JobResult.TaskName;
mailResult.Message = JobResult?.Exception?.FullMessage ?? null;
Results.Add(mailResult);
}
}
}
catch (Exception ex)
{
logger.Error(ex, "The delivery via 'Mail' failed.");
JobResult.Exception = ReportException.GetException(ex);
JobResult.Status = TaskStatusInfo.ERROR;
var errorResult = new MailResult()
{
Success = false,
ReportState = "ERROR",
TaskName = JobResult?.TaskName ?? "Unknown Task",
Message = JobResult?.Exception?.FullMessage ?? null
};
Results.Add(errorResult);
}
}