private void ViewReportBtn_Click(object sender, RoutedEventArgs e)
{
ExecutionLoggerConfiguration _selectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
string reportsResultFolder = "";
if (!_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
Reporter.ToUser(eUserMsgKey.ExecutionsResultsProdIsNotOn);
return;
}
else if (reportsResultFolder == string.Empty)
{
Reporter.ToUser(eUserMsgKey.AutomationTabExecResultsNotExists);
return;
}
else
{
foreach (string txt_file in System.IO.Directory.GetFiles(reportsResultFolder))
{
string fileName = System.IO.Path.GetFileName(txt_file);
if (fileName.Contains(".html"))
{
Process.Start(reportsResultFolder);
Process.Start(reportsResultFolder + "\\" + fileName);
}
}
}
}
public void SetReportsConfigurations()
{
if ((this.ExecutionLoggerConfigurationSetList == null) || (this.ExecutionLoggerConfigurationSetList.Count == 0))
{
this.ExecutionLoggerConfigurationSetList = new ObservableList <ExecutionLoggerConfiguration>();
ExecutionLoggerConfiguration ExecutionLoggerConfiguration = new ExecutionLoggerConfiguration();
ExecutionLoggerConfiguration.IsSelected = true;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled = true;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationMaximalFolderSize = 250;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder = @"~\ExecutionResults\";
ExecutionLoggerConfigurationSetList.Add(ExecutionLoggerConfiguration);
}
if ((this.HTMLReportsConfigurationSetList == null) || (this.HTMLReportsConfigurationSetList.Count == 0))
{
this.HTMLReportsConfigurationSetList = new ObservableList <HTMLReportsConfiguration>();
HTMLReportsConfiguration HTMLReportsConfiguration = new HTMLReportsConfiguration();
HTMLReportsConfiguration.IsSelected = true;
HTMLReportsConfiguration.HTMLReportsFolder = @"~\HTMLReports\";
HTMLReportsConfiguration.HTMLReportsAutomaticProdIsEnabled = false;
HTMLReportsConfigurationSetList.Add(HTMLReportsConfiguration);
}
App.AutomateTabGingerRunner.ExecutionLogger.Configuration = this.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
}
private void ViewReportBtn_Click(object sender, RoutedEventArgs e)
{
ExecutionLoggerConfiguration _selectedExecutionLoggerConfiguration = App.UserProfile.Solution.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
string reportsResultFolder = "";
if (!_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
Reporter.ToUser(eUserMsgKeys.ExecutionsResultsProdIsNotOn);
return;
}
else if (reportsResultFolder == string.Empty)
{
Reporter.ToUser(eUserMsgKeys.AutomationTabExecResultsNotExists);
return;
}
else
{
foreach (string txt_file in System.IO.Directory.GetFiles(reportsResultFolder))
{
string fileName = System.IO.Path.GetFileName(txt_file);
if (fileName.Contains(".html"))
{
Process.Start(reportsResultFolder);
Process.Start(reportsResultFolder + "\\" + fileName);
}
}
}
}
public void SetRunnersExecutionLoggerConfigs()
{
mSelectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
if (mSelectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
DateTime currentExecutionDateTime = DateTime.Now;
Runners[0].ExecutionLoggerManager.RunSetStart(mSelectedExecutionLoggerConfiguration.CalculatedLoggerFolder, mSelectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationMaximalFolderSize, currentExecutionDateTime);
int gingerIndex = 0;
while (Runners.Count > gingerIndex)
{
Runners[gingerIndex].ExecutionLoggerManager.GingerData.Seq = gingerIndex + 1;
Runners[gingerIndex].ExecutionLoggerManager.GingerData.GingerName = Runners[gingerIndex].Name;
Runners[gingerIndex].ExecutionLoggerManager.GingerData.Ginger_GUID = Runners[gingerIndex].Guid;
Runners[gingerIndex].ExecutionLoggerManager.GingerData.GingerAggentMapping = Runners[gingerIndex].ApplicationAgents.Select(a => a.AgentName + "_:_" + a.AppName).ToList();
Runners[gingerIndex].ExecutionLoggerManager.GingerData.GingerEnv = Runners[gingerIndex].ProjEnvironment.Name.ToString();
Runners[gingerIndex].ExecutionLoggerManager.CurrentExecutionDateTime = currentExecutionDateTime;
Runners[gingerIndex].ExecutionLoggerManager.Configuration = mSelectedExecutionLoggerConfiguration;
//gingerIndex++;
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.GingerData.Seq = gingerIndex + 1;
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.GingerData.GingerName = Runners[gingerIndex].Name;
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.GingerData.Ginger_GUID = Runners[gingerIndex].Guid;
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.GingerData.GingerAggentMapping = Runners[gingerIndex].ApplicationAgents.Select(a => a.AgentName + "_:_" + a.AppName).ToList();
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.GingerData.GingerEnv = Runners[gingerIndex].ProjEnvironment.Name.ToString();
Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.CurrentExecutionDateTime = currentExecutionDateTime;
//Runners[gingerIndex].ExecutionLoggerManager.mExecutionLogger.Configuration = mSelectedExecutionLoggerConfiguration;
gingerIndex++;
}
}
}
void GenerateReport()
{
ExecutionLoggerConfiguration executionLoggerConfiguration = new ExecutionLoggerConfiguration();
// HTMLReportsConfiguration currentConf = WorkSpace.UserProfile.Solution.HTMLReportsConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
//get logger files
string exec_folder = Ginger.Run.ExecutionLogger.GetLoggerDirectory(executionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder + "\\" + Ginger.Run.ExecutionLogger.defaultAutomationTabLogName);
//create the report
string reportsResultFolder = Ginger.Reports.GingerExecutionReport.ExtensionMethods.CreateGingerExecutionReport(new ReportInfo(exec_folder), true, null, null, false, 100000);
if (reportsResultFolder == string.Empty)
{
Reporter.ToUser(eUserMsgKey.AutomationTabExecResultsNotExists);
}
else
{
foreach (string txt_file in System.IO.Directory.GetFiles(reportsResultFolder))
{
string fileName = Path.GetFileName(txt_file);
if (fileName.Contains(".html"))
{
System.Diagnostics.Process.Start(reportsResultFolder);
System.Diagnostics.Process.Start(reportsResultFolder + "\\" + fileName);
}
}
}
}
private void Businessflow_ClickGenerateReport(object sender, RoutedEventArgs e)
{
if (CheckCurrentRunnerIsNotRuning())
{
return;
}
BusinessFlow bf = (BusinessFlow)((RunnerItemPage)sender).ItemObject;
if (mRunner.ExecutionLoggerManager.Configuration.SelectedDataRepositoryMethod == ExecutionLoggerConfiguration.DataRepositoryMethod.LiteDB)
{
GenerateBFReport(bf);
return;
}
ExecutionLoggerConfiguration _selectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
HTMLReportsConfiguration currentConf = WorkSpace.Instance.Solution.HTMLReportsConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
if (WorkSpace.Instance.RunsetExecutor.RunSetConfig.LastRunsetLoggerFolder != null)
{
string reportpath = ((BusinessFlow)((RunnerItemPage)sender).ItemObject).ExecutionFullLogFolder;
string reportsResultFolder = string.Empty;
if (!string.IsNullOrEmpty(reportpath))
{
reportsResultFolder = Ginger.Reports.GingerExecutionReport.ExtensionMethods.CreateGingerExecutionReport(new ReportInfo(reportpath), false, null, currentConf.HTMLReportsFolder + Ginger.Run.ExecutionLoggerManager.defaultRunTabBFName + Ginger.Reports.GingerExecutionReport.ExtensionMethods.folderNameNormalazing(bf.Name));
}
if (!_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
Reporter.ToUser(eUserMsgKey.ExecutionsResultsProdIsNotOn);
return;
}
else if (reportsResultFolder == string.Empty)
{
Reporter.ToUser(eUserMsgKey.ExecutionsResultsNotExists);
return;
}
else
{
foreach (string txt_file in System.IO.Directory.GetFiles(reportsResultFolder))
{
string fileName = System.IO.Path.GetFileName(txt_file);
if (fileName.Contains(".html"))
{
Process.Start(reportsResultFolder);
Process.Start(reportsResultFolder + "\\" + fileName);
}
}
}
}
else
{
Context context = new Context();
context.BusinessFlow = bf;
context.Runner = mRunner;
context.Environment = mRunner.ProjEnvironment;
mRunner.ExecutionLoggerManager.GenerateBusinessFlowOfflineReport(context, currentConf.HTMLReportsFolder + bf.Name, WorkSpace.Instance.RunsetExecutor.RunSetConfig.Name);
}
}
public string GetRunSetLastExecutionLogFolderOffline()
{
if (WorkSpace.Instance.RunsetExecutor.RunSetConfig.LastRunsetLoggerFolder != null)
{
return(WorkSpace.Instance.RunsetExecutor.RunSetConfig.LastRunsetLoggerFolder);
}
else
{
ExecutionLoggerConfiguration _selectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
if (!_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
//TODO AppReporter.ToUser(eUserMsgKey.ExecutionsResultsProdIsNotOn);
return(string.Empty);
}
string exec_folder = folderNameNormalazing(WorkSpace.Instance.RunsetExecutor.RunSetConfig.Name) + "_" + DateTime.Now.ToString("MMddyyyy_HHmmssfff");
exec_folder = executionLoggerHelper.GetLoggerDirectory(Path.Combine(_selectedExecutionLoggerConfiguration.CalculatedLoggerFolder, exec_folder));
WorkSpace.Instance.RunsetExecutor.RunSetConfig.LastRunsetLoggerFolder = exec_folder;
int RunnerCount = 1;
RunSetStart(exec_folder, _selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationMaximalFolderSize, CurrentExecutionDateTime, true);
foreach (GingerRunner gingerrunner in WorkSpace.Instance.RunsetExecutor.RunSetConfig.GingerRunners)
{
string folder = Path.Combine(exec_folder, RunnerCount.ToString() + " " + gingerrunner.Name);
if (System.IO.Directory.Exists(folder))
{
executionLoggerHelper.CleanDirectory(folder);
}
else
{
System.IO.Directory.CreateDirectory(folder);
}
mContext = gingerrunner.Context;
Amdocs.Ginger.CoreNET.Execution.eRunStatus gingerRunnerStatus = gingerrunner.RunsetStatus;
if (gingerRunnerStatus != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed && gingerRunnerStatus != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed && gingerRunnerStatus != Amdocs.Ginger.CoreNET.Execution.eRunStatus.Stopped)
{
continue;
}
Configuration.ExecutionLoggerConfigurationIsEnabled = true;
mExecutionLogger.ExecutionLogfolder = folder;
gingerReport = new GingerReport();
RunnerRunStart(0, gingerrunner, true);
OfflineRunnerExecutionLog(gingerrunner, folder, RunnerCount);
RunnerCount++;
}
RunSetEnd(exec_folder, true);
return(exec_folder);
}
}
public string GenerateBusinessflowOfflineExecutionLogger(Context context, string RunsetName = null)
{
ExecutionLoggerConfiguration _selectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
if (!_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
return(string.Empty);
}
string exec_folder = string.Empty;
exec_folder = GenerateBusinessFlowOfflineFolder(_selectedExecutionLoggerConfiguration.CalculatedLoggerFolder, context.BusinessFlow.Name, RunsetName);
Configuration.ExecutionLoggerConfigurationIsEnabled = true;
context.Runner.SetBFOfflineData(context.BusinessFlow, (context.Runner.RunListeners[0] as ExecutionLoggerManager), exec_folder);
return(exec_folder);
}
public void CreateGingerExecutionReportAutomaticly()
{
HTMLReportsConfiguration currentConf = WorkSpace.Instance.Solution.HTMLReportsConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
mSelectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.LoggerConfigurations;
if ((mSelectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled) && (Runners != null) && (Runners.Count > 0))
{
if (mSelectedExecutionLoggerConfiguration.ExecutionLoggerHTMLReportsAutomaticProdIsEnabled)
{
string runSetReportName;
if (!string.IsNullOrEmpty(RunSetConfig.Name))
{
runSetReportName = RunSetConfig.Name;
}
else
{
runSetReportName = ExecutionLoggerManager.defaultRunTabLogName;
}
string exec_folder = new ExecutionLoggerHelper().GetLoggerDirectory(Path.Combine(mSelectedExecutionLoggerConfiguration.CalculatedLoggerFolder, runSetReportName + "_" + Runners[0].ExecutionLoggerManager.CurrentExecutionDateTime.ToString("MMddyyyy_HHmmss")));
}
}
}
public void CreateGingerExecutionReportAutomaticly()
{
HTMLReportsConfiguration currentConf = WorkSpace.Instance.Solution.HTMLReportsConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
mSelectedExecutionLoggerConfiguration = WorkSpace.Instance.Solution.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
if ((mSelectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled) && (Runners != null) && (Runners.Count > 0))
{
if (mSelectedExecutionLoggerConfiguration.ExecutionLoggerHTMLReportsAutomaticProdIsEnabled)
{
string runSetReportName;
if ((RunSetConfig.Name != null) && (RunSetConfig.Name != string.Empty))
{
runSetReportName = RunSetConfig.Name;
}
else
{
runSetReportName = ExecutionLogger.defaultRunTabLogName;
}
string exec_folder = ExecutionLogger.GetLoggerDirectory(mSelectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder + "\\" + runSetReportName + "_" + Runners[0].ExecutionLogger.CurrentExecutionDateTime.ToString("MMddyyyy_HHmmss"));
}
}
}
public void SetReportsConfigurations()
{
try
{
if (Solution.LoggerConfigurations == null || Solution.LoggerConfigurations.ExecutionLoggerConfigurationExecResultsFolder == null)
{
Solution.LoggerConfigurations = new ExecutionLoggerConfiguration();
Solution.LoggerConfigurations.IsSelected = true;
Solution.LoggerConfigurations.ExecutionLoggerConfigurationIsEnabled = true;
Solution.LoggerConfigurations.ExecutionLoggerConfigurationMaximalFolderSize = 250;
Solution.LoggerConfigurations.ExecutionLoggerConfigurationExecResultsFolder = SolutionRepository.cSolutionRootFolderSign + "ExecutionResults";
}
if ((Solution.HTMLReportsConfigurationSetList == null) || (Solution.HTMLReportsConfigurationSetList.Count == 0))
{
Solution.HTMLReportsConfigurationSetList = new ObservableList <HTMLReportsConfiguration>();
HTMLReportsConfiguration HTMLReportsConfiguration = new HTMLReportsConfiguration();
HTMLReportsConfiguration.IsSelected = true;
HTMLReportsConfiguration.HTMLReportTemplatesSeq = 1;
HTMLReportsConfiguration.HTMLReportsFolder = SolutionRepository.cSolutionRootFolderSign + "HTMLReports";
HTMLReportsConfiguration.HTMLReportsAutomaticProdIsEnabled = false;
Solution.HTMLReportsConfigurationSetList.Add(HTMLReportsConfiguration);
}
Solution.LoggerConfigurations.CalculatedLoggerFolder = Solution.LoggerConfigurations.ExecutionLoggerConfigurationExecResultsFolder;
Ginger.Reports.GingerExecutionReport.ExtensionMethods.GetSolutionHTMLReportConfigurations();
ExecutionLoggerConfiguration executionLoggerConfiguration = Solution.LoggerConfigurations;
// !!!!!!!!!!!!! FIXME
// ExecutionLogger executionLogger = App.AutomateTabGingerRunner.ExecutionLogger;
// executionLogger.Configuration = executionLoggerConfiguration;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void SetReportsConfigurations()
{
try {
if ((this.ExecutionLoggerConfigurationSetList == null) || (this.ExecutionLoggerConfigurationSetList.Count == 0))
{
this.ExecutionLoggerConfigurationSetList = new ObservableList <ExecutionLoggerConfiguration>();
ExecutionLoggerConfiguration ExecutionLoggerConfiguration = new ExecutionLoggerConfiguration();
ExecutionLoggerConfiguration.IsSelected = true;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled = true;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationMaximalFolderSize = 250;
ExecutionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder = @"~\ExecutionResults\";
ExecutionLoggerConfigurationSetList.Add(ExecutionLoggerConfiguration);
}
if ((this.HTMLReportsConfigurationSetList == null) || (this.HTMLReportsConfigurationSetList.Count == 0))
{
this.HTMLReportsConfigurationSetList = new ObservableList <HTMLReportsConfiguration>();
HTMLReportsConfiguration HTMLReportsConfiguration = new HTMLReportsConfiguration();
HTMLReportsConfiguration.IsSelected = true;
HTMLReportsConfiguration.HTMLReportTemplatesSeq = 1;
HTMLReportsConfiguration.HTMLReportsFolder = @"~\HTMLReports\";
HTMLReportsConfiguration.HTMLReportsAutomaticProdIsEnabled = false;
HTMLReportsConfigurationSetList.Add(HTMLReportsConfiguration);
}
Ginger.Reports.GingerExecutionReport.ExtensionMethods.GetSolutionHTMLReportConfigurations();
ExecutionLoggerConfiguration executionLoggerConfiguration = this.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
// !!!!!!!!!!!!! FIXME
// ExecutionLogger executionLogger = App.AutomateTabGingerRunner.ExecutionLogger;
// executionLogger.Configuration = executionLoggerConfiguration;
}
catch (Exception e)
{
}
}
public void CreateGingerExecutionReportAutomaticly()
{
HTMLReportsConfiguration currentConf = App.UserProfile.Solution.HTMLReportsConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
_selectedExecutionLoggerConfiguration = App.UserProfile.Solution.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
if ((_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled) && (Runners != null) && (Runners.Count > 0))
{
if (_selectedExecutionLoggerConfiguration.ExecutionLoggerHTMLReportsAutomaticProdIsEnabled)
{
string runSetReportName;
if ((RunSetConfig.Name != null) && (RunSetConfig.Name != string.Empty))
{
runSetReportName = RunSetConfig.Name;
}
else
{
runSetReportName = ExecutionLogger.defaultRunTabLogName;
}
string exec_folder = ExecutionLogger.GetLoggerDirectory(_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder + "\\" + runSetReportName + "_" + Runners[0].ExecutionLogger.CurrentExecutionDateTime.ToString("MMddyyyy_HHmmss"));
string reportsResultFolder = Ginger.Reports.GingerExecutionReport.ExtensionMethods.CreateGingerExecutionReport(new ReportInfo(exec_folder), false, null, null, false, currentConf.HTMLReportConfigurationMaximalFolderSize);
}
}
}
public void SetRunnersExecutionLoggerConfigs()
{
_selectedExecutionLoggerConfiguration = App.UserProfile.Solution.ExecutionLoggerConfigurationSetList.Where(x => (x.IsSelected == true)).FirstOrDefault();
if (_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationIsEnabled)
{
DateTime currentExecutionDateTime = DateTime.Now;
Ginger.Run.ExecutionLogger.RunSetStart(_selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationExecResultsFolder, _selectedExecutionLoggerConfiguration.ExecutionLoggerConfigurationMaximalFolderSize, currentExecutionDateTime);
int ginger_index = 0;
while (Runners.Count > ginger_index)
{
Runners[ginger_index].ExecutionLogger.GingerData.Seq = ginger_index + 1;
Runners[ginger_index].ExecutionLogger.GingerData.GingerName = Runners[ginger_index].Name;
Runners[ginger_index].ExecutionLogger.GingerData.Ginger_GUID = Runners[ginger_index].Guid;
Runners[ginger_index].ExecutionLogger.GingerData.GingerAggentMapping = Runners[ginger_index].ApplicationAgents.Select(a => a.AgentName + "_:_" + a.AppName).ToList();
Runners[ginger_index].ExecutionLogger.GingerData.GingerEnv = Runners[ginger_index].ProjEnvironment.Name.ToString();
Runners[ginger_index].ExecutionLogger.CurrentExecutionDateTime = currentExecutionDateTime;
Runners[ginger_index].ExecutionLogger.Configuration = _selectedExecutionLoggerConfiguration;
ginger_index++;
}
}
}