public override IError RemoveItem(string name)
{
IError error = new QvError();
foreach (var item in ReportConfig.QvReportManager.ItemCollection.Values)
{
if (name == item.Connection.Name)
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The report {0} connect to this connection.", item.Name));
break;
}
}
foreach (var item in ReportConfig.QvReportManager.ItemCollection.Values)
{
if (name == item.Connection.Name)
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The Filter {0} connect to this connection.", item.Name));
}
}
if (error.HasError == false)
{
this.ItemCollection.Remove(name);
this.Save();
}
return(error);
}
public override IError RemoveItem(string name)
{
IError error = new QvError();
foreach (var item in ReportConfig.ReportTaskManager.ItemCollection.Values)
{
if (item.Recipients.ContainsKey(name))
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The task {0} connect to this recipient.", item.Name));
break;
}
}
foreach (var item in ReportConfig.RecipientGroupManager.ItemCollection.Values)
{
if (item.RecipientList.ContainsKey(name))
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The recipient group {0} connect to this recipient.", item.Name));
break;
}
}
if (error.HasError == false)
{
this.ItemCollection.Remove(name);
this.Save();
}
return(error);
}
public virtual IError RemoveItem(string name)
{
IError error = new QvError();
this.ItemCollection.Remove(name);
this.Save();
return(error);
}
public override IError RemoveItem(string name)
{
IError error = new QvError();
foreach (var item in ReportConfig.QvReportManager.ItemCollection.Values)
{
if (item.Filter != null && item.Filter.Name == name)
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The Report {0} connect to this filter.", item.Name));
break;
}
}
return(error);
}
public override IError RemoveItem(string name)
{
IError error = new QvError();
foreach (var item in ReportConfig.SchedulerManager.ItemCollection.Values)
{
if (item.Tasks.ContainsKey(name))
{
error.HasError = true;
error.ErrorMessage.AppendLine(string.Format("The scheduler {0} connect to this task.", item.Name));
break;
}
}
if (error.HasError == false)
{
this.ItemCollection.Remove(name);
ReportConfig.ConfigLocations.Remove(name);
this.Save();
}
return(error);
}
public IError RunTask(ReportTask task, SmtpServer smtpServer)
{
IError taskError = new QvError();
try
{
this.Logger.Message("Begin to Run task [" + task.Name + "]------------------------------------------------");
this.Logger.Message("Preview the connection. ");
this.ConnectionPreview(task.Reports.Values.First());
this.Logger.Message(string.Format("Task [{0}] have reports [{1}]", task.Name, string.Join(",", task.Reports.Keys.ToArray())));
List<ReportContext> reports;
List<string> missingExportReports;
IError error = this.PopulateReportContext(task, smtpServer, out reports, out missingExportReports);
if (error.HasError)
{
taskError.HasError = true;
taskError.ErrorMessage.AppendLine(error.ErrorMessage.ToString());
}
else
{
#region Send Mail
if (smtpServer.Validate() && reports.Count > 0)
{
SmtpClientAdaptor smtpClient = new SmtpClientAdaptor(smtpServer);
//Get the recipients
List<string> recipients = task.Recipients.Values.Select(x => x.Email).ToList();
if (task.Group != null)
{
foreach (var r in task.Group.RecipientList.Values)
{
if (!recipients.Contains(r.Email))
recipients.Add(r.Email);
}
}
if (recipients.Count > 0)
{
if (task.IsSendMailInSingleMail)
{
smtpClient.SendEmail(task.MessageDefinition, reports, recipients);
}
else
{
foreach (var item in reports)
{
List<ReportContext> list = new List<ReportContext>();
list.Add(item);
smtpClient.SendEmail(task.MessageDefinition, list, recipients);
}
}
}
else
{
this.Logger.Error("No recipients set up");
}
}
else
{
this.Logger.Error("SMTP SERVER Validate failed or there is no report exported, can not send email.");
this.Logger.Info("Exported reports count " + reports.Count);
}
#endregion
#region Upload to Ftp Server
if (task.FtpServer != null)
{
string remoteFile = string.Empty;
try
{
FtpClient client = new FtpClient(task.FtpServer.Host, task.FtpServer.Username, task.FtpServer.Password, task.FtpServer.Port);
foreach (var item in reports)
{
if (!string.IsNullOrWhiteSpace(task.FtpServer.Folder))
remoteFile = task.FtpServer.Folder + (task.FtpServer.Folder.EndsWith("/") ? string.Empty : "/") + item.OutputFullName.Split("\\".ToArray())[item.OutputFullName.Split("\\".ToArray()).Length - 1];
else
remoteFile = item.OutputFullName.Split("\\".ToArray())[item.OutputFullName.Split("\\".ToArray()).Length - 1];
client.Upload(remoteFile, item.OutputFullName);
}
}
catch (Exception ex)
{
this.Logger.Error("Ftp upload failed!" + ex.Message + ex.StackTrace);
MailHelper.ExceptionNotify("Ftp upload failed", ex.Message + ex.StackTrace + "\n" + "Remote file:" + remoteFile, smtpServer);
}
}
#endregion
if (missingExportReports.Count > 0)
{
string subject = "Some reports can not be exported";
string message = string.Join("\n\r", missingExportReports);
MailHelper.ExceptionNotify(subject, message, smtpServer);
taskError.HasError = true;
taskError.ErrorMessage.AppendLine(message);
}
}
}
catch (Exception ex)
{
this.Logger.Error("Failed to run the task [" + task.Name + "] Error:" + ex.Message + "\n"+ ex.StackTrace);
try
{
if (!string.IsNullOrEmpty(smtpServer.ExceptionTo))
{
string subject = "QlikView Report Export&MailSend system Exception";
StringBuilder sb = new StringBuilder();
sb.AppendLine("Task name: " + task.Name);
sb.AppendLine(string.Empty);
sb.AppendLine("Exception message: " + ex.Message);
sb.AppendLine("Stack Trace---------------");
sb.AppendLine(ex.StackTrace);
MailHelper.ExceptionNotify(subject, sb.ToString(), smtpServer);
taskError.HasError = true;
taskError.ErrorMessage.AppendLine(sb.ToString());
}
}
catch (Exception ex1)
{
this.Logger.Error("Send exception mail failed. " + ex.Message + "\n" + ex1.StackTrace);
}
}
this.Logger.Message("Complete running the task----------------------------------------------------------");
return taskError;
}
private IError PopulateReportContext(ReportTask task, SmtpServer smtpServer, out List<ReportContext> exportedReports, out List<string> missingReports)
{
exportedReports = new List<ReportContext>();
missingReports = new List<string>();
List<ReportContext> excelReports = new List<ReportContext>();
string folder = string.Empty;
if (task.OutputFolder.EndsWith(@"\"))
{
folder = task.OutputFolder.Remove(task.OutputFolder.Length - 1);
}
else
{
folder = task.OutputFolder;
}
IError error = new QvError();
#region Export report
foreach (var item in task.Reports.Values)
{
this.Logger.Message("Running report [" + item.Name + "]");
this.Logger.Message("Setting connection [" + item.Connection.Name + "]");
string fileName;
error = this.ExportReport(item, folder, out fileName);
if (error.HasError == false)
{
if (item.ReportType != Common.ReportType.Excel)
exportedReports.Add(new ReportContext()
{
Name = item.Name,
Description = item.Description,
OutputFullName = fileName,
ReportType = item.ReportType,
HtmlFormat = this.GetHtml(item, fileName)
});
else
excelReports.Add(new ReportContext()
{
Name = item.Name,
Description = item.Description,
OutputFullName = fileName,
ReportType = item.ReportType,
HtmlFormat = this.GetHtml(item, fileName)
});
this.Logger.Message("Export report [" + item.Name + "] complete");
}
else
{
missingReports.Add(fileName);
this.Logger.Error(string.Format("The report [{0}] cannot be exported.", fileName));
}
}
if (task.IsMergeInSingleExcel)
{
this.Logger.Message("Begin Merge in single excel");
ReportContext mergedReport;
string mergedFileName = folder + @"\" + task.Name + ".xls";
error = this.MergeExcelReports(excelReports, mergedFileName, task.Name, out mergedReport);
if (error.HasError == false)
{
exportedReports.Add(mergedReport);
this.Logger.Message("Succed to merge in single excel");
}
else
{
this.Logger.Message("Failed to merge, retain multiple files \n" + error.ErrorMessage);
MailHelper.ExceptionNotify("Failed to merge files for task " + task.Name, error.ErrorMessage.ToString(), smtpServer);
}
}
else
{
exportedReports.AddRange(excelReports);
}
#endregion
return error;
}
private IError MergeExcelReports(List<ReportContext> excelReports, string mergedFileName, string taskName, out ReportContext mergedReport)
{
IError error = new QvError();
mergedReport = new ReportContext();
try
{
Dictionary<string, ReportContext> mergedFiles = excelReports.ToDictionary(x => x.Name, x => x);
//Create a thread to execute merge file
string outputFile = string.Empty;
Func<bool> function = () =>
{
IExcelMerge excel = ExcelMergeFactory.Create(taskName);
excel.Logger = this.Logger;
return excel.MergeFiles(mergedFiles, mergedFileName, out outputFile);
};
Task<bool> task = new Task<bool>(function);
task.Start();
task.Wait();
mergedReport.Name = "mergedReport";
mergedReport.OutputFullName = outputFile;
mergedReport.ReportType = Common.ReportType.Excel;
mergedReport.HtmlFormat = string.Empty;
if (task.Result)
error.HasError = false;
else
error.HasError = true;
}
catch (Exception ex)
{
error.HasError = true;
error.ErrorMessage = new StringBuilder(ex.Message + "\n" + ex.StackTrace);
this.Logger.Error(ex.Message);
this.Logger.Error(ex.StackTrace);
}
return error;
}
private IError ExportReport(QlikViewReport report, string outputFolder, out string outputFile)
{
IError error = new QvError();
outputFile = string.Empty;
this._qlikViewConnector.SetConnection(report.Connection);
this.Logger.Message("Verify the connection....");
bool verified = this._qlikViewConnector.VerifyConnection();
if (verified)
{
if (report.Filter != null)
this.Logger.Message("Setting Filter: [" + report.Filter.Name + "] Fields:[" + string.Join(",", report.Filter.Fields.Keys.ToArray()) + "]");
this._qlikViewConnector.SetFilter(report.Filter);
if (report.EnableDynamicNaming)
{
if (report.ReportType == Common.ReportType.CSV)
outputFile = outputFolder + @"\" + report.OutputFielName.Replace(".", "_" + DateTime.Now.ToString("yyyyMMdd") + ".");
else
outputFile = outputFolder + @"\" + report.OutputFielName.Replace(".", "_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".");
}
else
{
outputFile = outputFolder + @"\" + report.OutputFielName;
}
this.Logger.Message("Export filename: " + outputFile);
//export file
int returnCode = -1;
if (report.ReportType == Common.ReportType.Excel)
returnCode = this._qlikViewConnector.ExportExcel(report.QlikViewExportObjectId, outputFile);
else if (report.ReportType == Common.ReportType.Html)
returnCode = this._qlikViewConnector.ExportHtml(report.QlikViewExportObjectId, outputFile);
else if (report.ReportType == Common.ReportType.JPG)
returnCode = this._qlikViewConnector.ExportJPG(report.QlikViewExportObjectId, outputFile);
else if (report.ReportType == Common.ReportType.CSV)
{
if (File.Exists(outputFile))
File.Delete(outputFile);
returnCode = this._qlikViewConnector.ExportCSV(report.QlikViewExportObjectId, outputFile);
}
this.Logger.Message(string.Format("Export return code [{0}]", returnCode));
//Check the file if exported
if (!File.Exists(outputFile))
{
//export again
this.Logger.Error(string.Format("The file {0} is not exported at the first time.", outputFile));
}
if (returnCode > -1)
error.HasError = false;
else
error.HasError = true;
}
else
{
this.Logger.Error(string.Format("Veriy the connection {0} failed. Can not open the document. The report can not be exported.", report.Name));
error.HasError = true;
}
return error;
}
protected void RunTask(IReportItem reportItem)
{
if (this.TaskRunning != null)
{
this.TaskRunning(this, new EventArgs());
}
IError error = null;
ReportTask task = null;
try
{
task = reportItem as ReportTask;
ExportEngine engine = new ExportEngine(QlikViewConnectorProxy.Instance);
engine.Logger = new QVConfigLog();
error = engine.RunTask(task, ReportConfig.SmtpServerManager.SmtpServer);
}
catch (Exception ex)
{
if (error == null)
error = new QvError();
error.ErrorMessage.Append(ex.StackTrace);
error.HasError = true;
}
this.DeleteAllExportedFiles(task);
if (this.TaskRunCompleted != null)
this.TaskRunCompleted(error);
}
protected void ExportReport(IReportItem reportItem)
{
if (this.ExportReportRunning != null)
{
this.ExportReportRunning(this, new EventArgs());
}
IError error = new QvError();
QlikViewReport report = null;
try
{
report = reportItem as QlikViewReport;
ExportEngine engine = new ExportEngine(QlikViewConnectorProxy.Instance);
engine.Logger = new QVConfigLog();
bool succeed = engine.RunReport(report, ReportConfig.SmtpServerManager.SmtpServer);
if (succeed)
{
error.HasError = false;
}
else
{
error.ErrorMessage.Append(string.Format("Export Report {0} failed.",report.Name));
error.HasError = true;
}
}
catch (Exception ex)
{
if (error == null)
error = new QvError();
error.ErrorMessage.Append(ex.StackTrace);
error.HasError = true;
}
if (this.ExportReportCompleted != null)
this.ExportReportCompleted(error);
}
