public async Task ReadByDateAndUserAsync_Should_Filter_By_UserId()
{
var teamId = Guid.NewGuid();
var userId1 = Guid.NewGuid();
var userId2 = Guid.NewGuid();
var reportDate = new DateTime(2019, 1, 14);
var reportDateItemIdentifier = new ReportDateItemIdentifier
{
TeamId = teamId,
Date = reportDate,
UserId = userId1
};
var reportTask1 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state",
Problems = "some problems",
Url = "some url",
Theme = "some theme",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
var reportTask2 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state2",
Problems = "some problems2",
Url = "some url2",
Theme = "some theme2",
IsPublic = true,
DateItemIdentifier = new ReportDateItemIdentifier
{
Date = reportDateItemIdentifier.Date,
UserId = userId2,
TeamId = reportDateItemIdentifier.TeamId
}
};
var reportTask3 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state3",
Problems = "some problems",
Url = "some url3",
Theme = "some theme3",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
await repository.SaveAsync(reportTask1).ConfigureAwait(false);
await repository.SaveAsync(reportTask2).ConfigureAwait(false);
await repository.SaveAsync(reportTask3).ConfigureAwait(false);
var readedTask = await repository.ReadByDateAndUserAsync(reportDateItemIdentifier, true).ConfigureAwait(false);
readedTask.Should().BeEquivalentTo(new List <ReportTask> {
reportTask1, reportTask3
});
}
public StaticCommandList()
{
InitializeComponent();
_myContext = new MyContext();
_reportTask = new ReportTask();
IoC.Container.Register <IHistoryManager, HistoryManager <MyContext> >();
IoC.Container.Register <MyContext, MyContext>();
var historyBrowserConfiguation = IoC.Resolve <IHistoryBrowserConfiguration>();
var historyManagerRetriever = IoC.Resolve <IHistoryManagerRetriever>();
historyBrowserConfiguation.AddDynamicColumn("p1", "A wonderful p1");
historyBrowserConfiguation.AddDynamicColumn("p2", "A great p2");
HistoryColumns.ColumnByName("p1").Position = 0;
HistoryColumns.User.Position = 1;
HistoryColumns.Description.Position = 2;
HistoryColumns.ColumnByName("p2").Position = 3;
HistoryColumns.Description.Position = 4;
HistoryColumns.State.Position = 5;
_historyManager = historyManagerRetriever.Current;
_historyBrowserPresenter = IoC.Resolve <IHistoryBrowserPresenter>();
_historyBrowserPresenter.Initialize();
var control = _historyBrowserPresenter.View as Control;
control.Dock = DockStyle.Fill;
panelControl1.Controls.Add(control);
_historyBrowserPresenter.HistoryManager = _historyManager;
_historyBrowserPresenter.UpdateHistory();
}
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);
}
}
public void Setup()
{
processor = new ReportTask();
payer = DataMother.CreatePayer();
Save(payer);
}
public async Task ReadByDateAndUserAsync_Should_Return_Exactly_Saved_Task()
{
var teamId = Guid.NewGuid();
var userId = Guid.NewGuid();
var reportDate = new DateTime(2019, 1, 14);
var reportDateItemIdentifier = new ReportDateItemIdentifier
{
TeamId = teamId,
Date = reportDate,
UserId = userId
};
var reportTask = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state",
Problems = "some problems",
Url = "some url",
Theme = "some theme",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
await repository.SaveAsync(reportTask).ConfigureAwait(false);
var readedTask = await repository.ReadByDateAndUserAsync(reportDateItemIdentifier, true).ConfigureAwait(false);
readedTask.Should().BeEquivalentTo(reportTask);
}
public void ReportAdd(QlikViewReport report)
{
ReportTask task = this.ReportItem as ReportTask;
if (task.Reports.ContainsKey(report.Name))
{
MessageBox.Show("The same name report exists, cannot add.");
return;
}
task.Reports.Add(report.Name, report);
}
private void btnFtpSetting_Click(object sender, RoutedEventArgs e)
{
ReportTask task = this.ViewModel.ReportItem as ReportTask;
FtpSettings settingForm = new FtpSettings();
settingForm.FtpServer = task.FtpServer;
if (settingForm.ShowDialog() == true)
{
task.FtpServer = settingForm.FtpServer;
}
}
public void RecipientDelete(Recipient recipient)
{
if (recipient == null)
{
MessageBox.Show("Please select a recipient.");
return;
}
if (MessageBox.Show("Do you want to delete the recipient " + recipient.Name, "Delete", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
ReportTask task = this.ReportItem as ReportTask;
task.Recipients.Remove(recipient.Name);
}
}
public void ReportDelete(QlikViewReport report)
{
if (report == null)
{
MessageBox.Show("Please select an report.");
return;
}
if (MessageBox.Show("Do you want to delete the report " + report.Name, "Delete", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
ReportTask task = this.ReportItem as ReportTask;
task.Reports.Remove(report.Name);
this.ReportList.Add(report);
}
}
public void Run(string task)
{
ReportItemDictionary <ReportTask> tasks = ReportConfig.ReportTaskManager.ItemCollection;
ExportEngine engine = new ExportEngine(new QlikViewConnector());
engine.Logger = this.Logger;
ReportTask taskItem = tasks.Values.FirstOrDefault(x => x.Name.ToString() == task);
if (taskItem != null)
{
Console.WriteLine("Running task first time: " + taskItem.Name + ".......");
engine.Logger.Message("Running task first time: " + taskItem.Name + ".......");
IError error = engine.RunTask(taskItem, ReportConfig.SmtpServerManager.SmtpServer);
if (error.HasError == false)
{
Console.WriteLine("Running task fisrt time" + taskItem.Name + " complete.......");
engine.Logger.Message("Running task fisrt time" + taskItem.Name + " complete.......");
}
else
{
Console.WriteLine("Running task fisrt time " + taskItem.Name + " failed.......");
engine.Logger.Error("Running task fisrt time " + taskItem.Name + " failed....... \n" + error.ErrorMessage.ToString());
//MailHelper.ExceptionNotify("Running task fisrt time " + taskItem.Name + " failed", error.ErrorMessage.ToString(), ReportConfig.Instance.SmtpServer);
Console.WriteLine("Running task second time: " + taskItem.Name + ".......");
engine.Logger.Message("Running task second time: " + taskItem.Name + ".......");
error = engine.RunTask(taskItem, ReportConfig.SmtpServerManager.SmtpServer);
if (error.HasError)
{
MailHelper.ExceptionNotify("Running task second time " + taskItem.Name + " failed", error.ErrorMessage.ToString(), ReportConfig.SmtpServerManager.SmtpServer);
}
}
}
else
{
engine.Logger.Error(string.Format("There is no task {0}. ", task));
}
this.Close();
}
private void DeleteAllExportedFiles(ReportTask task)
{
string folder = string.Empty;
if (task.OutputFolder.EndsWith(@"\"))
{
folder = task.OutputFolder.Remove(task.OutputFolder.Length - 1);
}
else
{
folder = task.OutputFolder;
}
if (File.Exists(folder + @"\DeleteCmd.bat"))
{
System.Diagnostics.Process.Start(folder + @"\DeleteCmd.bat");
}
}
public async Task ReadByDateAndUserAsync_Should_Return_Empty_List_If_There_Are_No_Suitable_Tasks()
{
var reportDateItemIdentifier = new ReportDateItemIdentifier
{
TeamId = Guid.NewGuid(),
Date = new DateTime(2019, 1, 14),
UserId = Guid.NewGuid()
};
var reportTask1 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state",
Problems = "some problems",
Url = "some url",
Theme = "some theme",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
var reportTask2 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state2",
Problems = "some problems2",
Url = "some url2",
Theme = "some theme2",
IsPublic = false,
DateItemIdentifier = reportDateItemIdentifier
};
await repository.SaveAsync(reportTask1).ConfigureAwait(false);
await repository.SaveAsync(reportTask2).ConfigureAwait(false);
var readedTask = await repository.ReadByDateAndUserAsync(new ReportDateItemIdentifier
{
Date = DateTime.Now,
UserId = Guid.NewGuid(),
TeamId = Guid.NewGuid()
}, true).ConfigureAwait(false);
readedTask.Should().BeEquivalentTo(EmptyCollection <ReportTask> .List);
}
public async Task DeleteAsync_Should_Do_Nothing_When_Trying_To_Delete_Absent_Task()
{
var reportDateItemIdentifier = new ReportDateItemIdentifier
{
TeamId = Guid.NewGuid(),
Date = new DateTime(2019, 1, 14),
UserId = Guid.NewGuid()
};
var taskId1 = Guid.NewGuid();
var reportTask1 = new ReportTask
{
Id = taskId1,
CurrentState = "some state",
Problems = "some problems",
Url = "some url",
Theme = "some theme",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
var reportTask2 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state2",
Problems = "some problems2",
Url = "some url2",
Theme = "some theme2",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
await repository.SaveAsync(reportTask1).ConfigureAwait(false);
await repository.SaveAsync(reportTask2).ConfigureAwait(false);
await repository.DeleteAsync(Guid.NewGuid()).ConfigureAwait(false);
var readedTask = await repository.ReadByDateAsync(reportDateItemIdentifier.TeamId, reportDateItemIdentifier.Date, true).ConfigureAwait(false);
readedTask.Should().BeEquivalentTo(new List <ReportTask> {
reportTask1, reportTask2
});
}
private void CreateTemplate(ReportTask task)
{
System.Diagnostics.Debug.WriteLine(string.Format("Neuer Report Task: Template erstellen {0}", task.TaskId));
try
{
using (Report_PPT report = new Report_PPT(task, _globalSettings.ReportDirectory_PPT, _globalSettings.ReportDirectory_PPT_Template, _rm, _globalSettings)) {
try
{
report.Process();
}catch (Exception e)
{
report.AddErrorToLog(e.ToString());
System.Diagnostics.Debug.WriteLine("Fehler Template erstellen: " + e.ToString());
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Fehler Template erstellen: " + ex.ToString());
}
}
public Task SaveAsync(ReportTask reportTask)
{
if (reportTask == null)
{
throw new ArgumentNullException(nameof(reportTask));
}
if (reportTask.DateItemIdentifier == null)
{
throw new ArgumentNullException(nameof(ReportTask.DateItemIdentifier));
}
return(queryExecuter.QueryAsync(async connection =>
{
var saveParameters = new ReportTaskStored
{
Id = reportTask.Id,
UserId = reportTask.DateItemIdentifier.UserId,
TeamId = reportTask.DateItemIdentifier.TeamId,
TaskDate = reportTask.DateItemIdentifier.Date,
IsPublic = reportTask.IsPublic,
Url = reportTask.Url,
Theme = reportTask.Theme,
CurrentState = reportTask.CurrentState,
Problems = reportTask.Problems,
};
var saveResult = await connection.ExecuteAsync(SaveQuery, saveParameters).ConfigureAwait(false);
Log.Information("ReportTask ({Id}, {UserId}, {TeamId}, {TaskDate}, {IsPublic}, {Url}, {Theme}, {CurrentState}, {Problems}) " +
"inserted with result {SaveResult}",
reportTask.Id,
reportTask.DateItemIdentifier.UserId,
reportTask.DateItemIdentifier.TeamId,
reportTask.DateItemIdentifier.Date,
reportTask.IsPublic,
reportTask.Url,
reportTask.Theme,
reportTask.CurrentState,
reportTask.Problems,
saveResult);
}));
}
protected override bool OnQvItemAdd(IReportItem qvItem)
{
try
{
ReportTask task = qvItem as ReportTask;
if (string.IsNullOrWhiteSpace(task.Name) || string.IsNullOrWhiteSpace(task.OutputFolder))
{
MessageBox.Show("The name and output folder are required.");
return(false);
}
ReportConfig.ReportTaskManager.AddItem(qvItem);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
return(true);
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
ReportTask task = this.ViewModel.ReportItem as ReportTask;
if (task.Group == null)
{
this.comboBoxGroup.SelectedIndex = 0;
}
else
{
this.comboBoxGroup.SelectedValue = task.Group;
}
if (this.ViewModel.IsNew)
{
this.gridName.Visibility = System.Windows.Visibility.Visible;
this.stackNewActions.Visibility = System.Windows.Visibility.Visible;
}
else
{
this.gridName.Visibility = System.Windows.Visibility.Collapsed;
this.stackNewActions.Visibility = System.Windows.Visibility.Collapsed;
}
}
public void checkSQL()
{
string initialSQL = "", error = "";
try
{
if (Instance is ReportModel)
{
ReportModel model = Instance as ReportModel;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", model, _compilationErrors);
}
error = model.Source.CheckSQL(RazorHelper.CompileExecute(sqlTextBox.Text, model), null, model, true);
}
else
{
var sql = !string.IsNullOrEmpty(SqlToCheck) ? SqlToCheck : sqlTextBox.Text;
if (model.IsLINQ)
{
error = model.Source.CheckLINQ(sql, model.FromTables, model);
}
else
{
error = model.Source.CheckSQL(sql, model.FromTables, model, false);
}
}
}
if (Instance is MetaEnum)
{
MetaEnum anEnum = Instance as MetaEnum;
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", anEnum, _compilationErrors);
}
error = anEnum.Source.CheckSQL(RazorHelper.CompileExecute(sqlTextBox.Text, anEnum), null, null, false);
}
else if (Instance is MetaSource)
{
MetaSource source = Instance as MetaSource;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", source, _compilationErrors);
}
error = source.CheckSQL(RazorHelper.CompileExecute(sqlTextBox.Text, source), null, null, true);
}
}
else if (Instance is MetaTable)
{
MetaTable table = Instance as MetaTable;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", table, _compilationErrors);
}
error = table.Source.CheckSQL(RazorHelper.CompileExecute(sqlTextBox.Text, table), null, null, true);
}
else
{
if (PropertyName == "WhereSQL")
{
initialSQL = table.WhereSQL;
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", table, _compilationErrors);
}
table.WhereSQL = RazorHelper.CompileExecute(sqlTextBox.Text, table);
}
else
{
initialSQL = table.Sql;
table.Sql = sqlTextBox.Text;
}
try
{
table.CheckTable(null);
if (sqlTextBox.ReadOnly)
{
table.SetReadOnly();
}
error = table.Error;
}
finally
{
if (PropertyName == "WhereSQL")
{
table.WhereSQL = initialSQL;
}
else
{
table.Sql = initialSQL;
}
}
}
}
else if (Instance is MetaJoin)
{
MetaJoin join = Instance as MetaJoin;
initialSQL = join.Clause;
try
{
join.Clause = sqlTextBox.Text;
join.CheckJoin();
if (sqlTextBox.ReadOnly)
{
join.SetReadOnly();
}
error = join.Error;
}
finally
{
join.Clause = initialSQL;
}
}
else if (Instance is ReportTask)
{
ReportTask task = Instance as ReportTask;
if (sqlTextBox.Text.StartsWith("@"))
{
FormHelper.CheckRazorSyntax(sqlTextBox, "", task, _compilationErrors);
}
error = task.Source.CheckSQL(RazorHelper.CompileExecute(sqlTextBox.Text, task), null, null, false);
}
}
catch (Exception ex)
{
error = ex.Message;
}
errorTextBox.Text = error;
if (!string.IsNullOrEmpty(error))
{
toolStripStatusLabel.Text = "Error";
toolStripStatusLabel.Image = global::Seal.Properties.Resources.error2;
}
else
{
toolStripStatusLabel.Text = "Script checked successfully";
toolStripStatusLabel.Image = global::Seal.Properties.Resources.checkedGreen;
}
}
public TaskHelper(ReportTask task)
{
_task = task;
}
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);
}
public async Task ReadByDateAsync_Should_Return_Tasks_Of_All_Users_In_Team()
{
var teamId = Guid.NewGuid();
var userId = Guid.NewGuid();
var reportDate = new DateTime(2019, 1, 14);
var reportDateItemIdentifier = new ReportDateItemIdentifier
{
TeamId = teamId,
Date = reportDate,
UserId = userId
};
var reportTask1 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state",
Problems = "some problems",
Url = "some url",
Theme = "some theme",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
var reportTask2 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state2",
Problems = "some problems2",
Url = "some url2",
Theme = "some theme2",
IsPublic = true,
DateItemIdentifier = reportDateItemIdentifier
};
var reportTask3 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state3",
Problems = "some problems3",
Url = "some url3",
Theme = "some theme3",
IsPublic = true,
DateItemIdentifier = new ReportDateItemIdentifier
{
Date = reportDateItemIdentifier.Date.AddDays(2),
TeamId = reportDateItemIdentifier.TeamId,
UserId = reportDateItemIdentifier.UserId
}
};
var reportTask4 = new ReportTask
{
Id = Guid.NewGuid(),
CurrentState = "some state4",
Problems = "some problems4",
Url = "some url4",
Theme = "some theme4",
IsPublic = true,
DateItemIdentifier = new ReportDateItemIdentifier
{
Date = reportDateItemIdentifier.Date,
TeamId = reportDateItemIdentifier.TeamId,
UserId = Guid.NewGuid()
}
};
await repository.SaveAsync(reportTask1).ConfigureAwait(false);
await repository.SaveAsync(reportTask3).ConfigureAwait(false);
await repository.SaveAsync(reportTask2).ConfigureAwait(false);
await repository.SaveAsync(reportTask4).ConfigureAwait(false);
var readedTask = await repository.ReadByDateAsync(teamId, reportDate, true).ConfigureAwait(false);
readedTask.Should().BeEquivalentTo(new List <ReportTask> {
reportTask1, reportTask2, reportTask4
});
}
public void start()
{
if (this.messageHandler == null)
throw new NullReferenceException("messageHandler must not be null");
if (this.reportUrl == null)
throw new NullReferenceException("reportUrl must not be null");
int queueSizeMultiple = 20;
long reportTimerInterval = 50;
//初始化消息队列
queue = new MessageCircleQueue(reportCount * queueSizeMultiple, timeoutSeconds);
//初始化消费线程数组
consumerThreads = new Thread[consumerThreadCount];
//构建消费者线程的Task任务
consumeTask = new consumeThreadTask(messageHandler, queue);
//构建线程委托任务
ThreadStart threadTask = new ThreadStart(consumeTask.doTask);
for (int i = 0; i < consumerThreads.Length; i++)
{
consumerThreads[i] = new Thread(threadTask);
consumerThreads[i].Start();
}
reportTask = new ReportTask(queue, reportUrl, appKey, secret);
reportTask.reportCount = reportCount;
reportTask.reportInterval = reportInterval;
TimerCallback tcb = reportTask.run;
timerTask = new Timer(tcb, null, reportTimerInterval, reportTimerInterval);
}
public void checkSQLToolStripButton_Click(object sender, EventArgs e)
{
string initialSQL = "", error = "";
try
{
if (Instance is ReportModel)
{
ReportModel model = Instance as ReportModel;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
error = model.Source.CheckSQL(Helper.ParseRazor(sqlTextBox.Text, model), null, model, true);
}
else
{
error = model.Source.CheckSQL(sqlTextBox.Text, model.FromTables, model, false);
}
}
if (Instance is MetaEnum)
{
MetaEnum anEnum = Instance as MetaEnum;
error = anEnum.Source.CheckSQL(sqlTextBox.Text, null, null, false);
}
else if (Instance is MetaSource)
{
MetaSource source = Instance as MetaSource;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
error = source.CheckSQL(Helper.ParseRazor(sqlTextBox.Text, source), null, null, true);
}
}
else if (Instance is MetaTable)
{
MetaTable table = Instance as MetaTable;
if (PropertyName == "PreSQL" || PropertyName == "PostSQL")
{
error = table.Source.CheckSQL(Helper.ParseRazor(sqlTextBox.Text, table), null, null, true);
}
else
{
if (PropertyName == "WhereSQL")
{
initialSQL = table.WhereSQL;
table.WhereSQL = Helper.ParseRazor(sqlTextBox.Text, table);
}
else
{
initialSQL = table.Sql;
table.Sql = sqlTextBox.Text;
}
try
{
table.CheckTable(null);
if (sqlTextBox.IsReadOnly)
{
table.SetReadOnly();
}
error = table.Error;
}
finally
{
if (PropertyName == "WhereSQL")
{
table.WhereSQL = initialSQL;
}
else
{
table.Sql = initialSQL;
}
}
}
}
else if (Instance is MetaJoin)
{
MetaJoin join = Instance as MetaJoin;
initialSQL = join.Clause;
try
{
join.Clause = sqlTextBox.Text;
join.CheckJoin();
if (sqlTextBox.IsReadOnly)
{
join.SetReadOnly();
}
error = join.Error;
}
finally
{
join.Clause = initialSQL;
}
}
else if (Instance is ReportTask)
{
ReportTask task = Instance as ReportTask;
error = task.Source.CheckSQL(Helper.ParseRazor(sqlTextBox.Text, task), null, null, false);
}
}
catch (Exception ex)
{
error = ex.Message;
}
errorTextBox.Text = error;
if (!string.IsNullOrEmpty(error))
{
toolStripStatusLabel.Text = "Error";
toolStripStatusLabel.Image = global::Seal.Properties.Resources.error2;
}
else
{
toolStripStatusLabel.Text = "SQL checked successfully";
toolStripStatusLabel.Image = global::Seal.Properties.Resources.checkedGreen;
}
}
public GetReportsResponse Beautify()
{
GetReportsResponse ret = null;
if (this.Status.Status == "200")
{
ret = new GetReportsResponse();
if (null != this.Report)
{
ret.Results = new List <GetReportsResponse.Result>();
foreach (WelcomeReport report in this.Report)
{
var r = new GetReportsResponse.Result();
r.Id = report.Id?.Id;
if (TryGetValue(report.Owner, out var owner) && TryGetValue(owner.Name, out var ownerName))
{
r.Owner = ownerName;
}
if (TryGetValue(report.Name, out var name))
{
r.Name = name.ToString();
}
r.Comment = report.Comment?.FirstOrDefault();
r.CreationTime = report.CreationTime.FirstOrDefault();
r.Writable = report.Writable.FirstOrDefault().As <bool>();
r.InUse = report.InUse.FirstOrDefault().As <bool>();
//r.TaskId = report.GetValue(p => p.Task).As<ReportFormat>()?.Empty?.Id?.ConvertTo<string>();
//r.TaskName = report.GetValue(p => p.Task).As<ReportFormat>()?.GetValue(p=>p.Name).As<string>();
ReportReport inner = report.Report.FirstOrDefault();
if (null != inner)
{
r.OmpVersion = inner.Omp.FirstOrDefault()?.Version.FirstOrDefault();
r.ScanRunStatus = inner.ScanRunStatus.FirstOrDefault();
r.VulnsCount = inner.Vulns.FirstOrDefault()?.Count?.FirstOrDefault();
r.AppCount = inner.Apps.FirstOrDefault()?.Count.FirstOrDefault();
r.SslCertsCount = inner.SslCerts.FirstOrDefault()?.Count.FirstOrDefault();
ReportTask task = inner.Task.FirstOrDefault();
if (null != task)
{
r.Task = new GetReportsResponse.Result.TaskInfo();
r.Task.Id = task.Empty?.Id;// task.GetValue(p => p.Empty).As<Filter>()?.Id;
r.Task.Name = task.Name?.FirstOrDefault();
r.Task.Comment = task.Comment?.FirstOrDefault();
r.Task.TargetId = task.Target?.FirstOrDefault()?.Empty?.Id;
r.Task.Progress = task.Progress?.FirstOrDefault();
}
r.ScanStart = inner.ScanStart.FirstOrDefault();
var ports = inner.Ports;
if (ports != null && ports.Length > 0)
{
var port = ports[0];
if (null != port && null != port.Port)
{
r.Ports = new List <GetReportsResponse.Result.PortInfo>();
foreach (PortPort prt in port.Port)
{
var entity = new GetReportsResponse.Result.PortInfo();
entity.Port = prt.Empty;
entity.Host = prt.Host?.FirstOrDefault();
entity.Severity = prt.Severity?.FirstOrDefault()?.As <double>();
entity.Threat = prt.Threat?.FirstOrDefault();
r.Ports.Add(entity);
}
}
}
var resultsArr = inner.Results;
if (resultsArr != null && resultsArr.Length > 0)
{
var results = resultsArr[0];
if (null != results && null != results.Result)
{
r.Results = new List <ResultInfo>();
foreach (ResultResult result in results.Result)
{
var entity = new ResultInfo();
entity.Id = result.Empty?.Id;
entity.Name = result.Name?.FirstOrDefault();
entity.Owner = result.Owner?.FirstOrDefault()?.Name.FirstOrDefault();
entity.Comment = result.Comment?.FirstOrDefault();
entity.CreationTime = result.CreationTime?.FirstOrDefault();
entity.ModificationTime = result.ModificationTime?.FirstOrDefault();
entity.Host = result.Host?.FirstOrDefault()?.Empty;
entity.AssetId = result.Host?.FirstOrDefault().Asset?.FirstOrDefault()?.Empty?.AssetId;
entity.Port = result.Port?.FirstOrDefault();
var nvt = result.Nvt.FirstOrDefault();
if (null != nvt)
{
entity.Nvt = new NvtInfo();
entity.Nvt.Oid = nvt.Empty?.Oid;
entity.Nvt.Type = nvt.Type?.FirstOrDefault();
entity.Nvt.Name = nvt.Name?.FirstOrDefault();
entity.Nvt.Family = nvt.Family?.FirstOrDefault();
entity.Nvt.CvssBase = nvt.CvssBase?.FirstOrDefault();
entity.Nvt.Cve = nvt.Cve?.FirstOrDefault();
entity.Nvt.Bid = nvt.Bid?.FirstOrDefault();
entity.Nvt.Xref = nvt.Xref?.FirstOrDefault();
entity.Nvt.Tags = nvt.Tags?.FirstOrDefault();
entity.Nvt.Cert = nvt.Cert?.FirstOrDefault()?.ToString();
}
entity.ScanNvtVersion = result.ScanNvtVersion?.FirstOrDefault();
entity.Threat = result.Threat?.FirstOrDefault();
entity.Severity = result.Severity?.FirstOrDefault();
entity.Qod = result.Qod?.FirstOrDefault()?.Value?.FirstOrDefault().ToString();
entity.QodType = result.Qod?.FirstOrDefault()?.Type.FirstOrDefault();
entity.Description = result.Description?.FirstOrDefault();
entity.OrginalThreat = result.OriginalThreat?.FirstOrDefault();
entity.OrginalSeverity = result.OriginalSeverity?.FirstOrDefault()?.As <double>();
entity.Notes = result.Notes?.FirstOrDefault();
entity.Overrides = result.Overrides?.FirstOrDefault();
r.Results.Add(entity);
}
}
ReportResultCount[] resultCountArr = inner.ResultCount;
if (null != resultCountArr && 0 != resultCountArr.Length)
{
ReportResultCount resultCount = resultCountArr[0];
if (null != resultCount)
{
r.ResultCount = new GetReportsResponse.Result.ResultCountInfo();
r.ResultCount.Total = resultCount.Empty;
r.ResultCount.Debug = resultCount.Debug?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
r.ResultCount.Hole = resultCount.Hole?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
r.ResultCount.Info = resultCount.Info?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
r.ResultCount.Log = resultCount.Log?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
r.ResultCount.Warning = resultCount.Warning?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
r.ResultCount.FalsePositive = resultCount.FalsePositive?.FirstOrDefault()?.Full?.FirstOrDefault()?.As <int>();
}
}
r.Severity = inner.Severity?.FirstOrDefault()?.Full?.FirstOrDefault().As <double>();
ReportHost host = inner.Host?.FirstOrDefault();
if (null != host)
{
r.Host = new GetReportsResponse.Result.HostInfo();
var model = r.Host;
model.Ip = host.Ip?.FirstOrDefault();
model.AssetId = host.Asset?.FirstOrDefault()?.Empty?.AssetId;
model.Start = host.Start?.FirstOrDefault();
model.End = host.End?.FirstOrDefault();
model.PortCount = host.PortCount?.FirstOrDefault()?.Page?.FirstOrDefault();
var rcArr = host.ResultCount;
if (null != rcArr && 0 != rcArr.Length)
{
var rc = rcArr[0];
model.ResultCount = new GetReportsResponse.Result.ResultCountInfo();
model.ResultCount.Total = rc.Page?.FirstOrDefault();
model.ResultCount.Hole = rc.Hole?.FirstOrDefault()?.Page?.FirstOrDefault();
model.ResultCount.Warning = rc.Warning?.FirstOrDefault()?.Page?.FirstOrDefault();
model.ResultCount.Info = rc.Info?.FirstOrDefault()?.Page?.FirstOrDefault();
model.ResultCount.Log = rc.Log?.FirstOrDefault()?.Page?.FirstOrDefault();
model.ResultCount.FalsePositive = rc.FalsePositive?.FirstOrDefault()?.Page?.FirstOrDefault();
}
var details = host.Detail;
if (null != details && 0 != details.Length)
{
model.Details = new List <GetReportsResponse.Result.HostInfo.Detail>();
foreach (var detail in details)
{
var d = new GetReportsResponse.Result.HostInfo.Detail();
d.Name = detail.Name?.FirstOrDefault();
d.Value = detail.Value?.FirstOrDefault();
d.SourceType = detail.Source?.FirstOrDefault()?.Type?.FirstOrDefault();
d.SourceName = detail.Source?.FirstOrDefault()?.Name?.FirstOrDefault();
d.SourceDescription = detail.Source?.FirstOrDefault()?.Description.FirstOrDefault();
d.Extra = detail.Extra?.FirstOrDefault();
model.Details.Add(d);
}
}
}
var hostStart = inner.HostStart?.FirstOrDefault();
if (null != hostStart)
{
r.HostStart = hostStart.Empty;
r.HostStartHost = hostStart.HostHost?.FirstOrDefault();
}
var hostEnd = inner.HostEnd?.FirstOrDefault();
if (null != hostEnd)
{
r.HostEnd = hostEnd.Empty;
r.HostEndHost = hostEnd.HostHost?.FirstOrDefault();
}
r.ScanEnd = inner.ScanEnd?.FirstOrDefault();
r.ErrorCount = inner.Errors?.FirstOrDefault()?.Count?.FirstOrDefault();
r.ReportFormat = inner.ReportFormat?.FirstOrDefault();
}
}
ret.Results.Add(r);
}
}
ret.Filters = this.Filters?.FirstOrDefault()?.Term?.FirstOrDefault();
if (null != this.Sort && 0 < this.Sort.Length)
{
var s = this.Sort[0];
ret.Sort = s.Field?.FirstOrDefault()?.Empty + ", " + s.Field?.FirstOrDefault()?.Order?.FirstOrDefault();
}
ret.ReportCount = this.ReportCount?.FirstOrDefault()?.Empty.As <int>();
}
return(ret);
}
