/// <summary>
///
/// </summary>
public static string[] BuildPortfolioResult(WSConnection connection, Application[] application)
{
//Build Quality Indicators
using (PortfolioBLL applicationBLL = new PortfolioBLL(connection, application))
{
List<string> Apps_SetSnapshots = applicationBLL.SetSnapshots();
List<string> Apps_SetQualityIndicators = applicationBLL.SetQualityIndicators();
List<string> Apps_SetSizingMeasure = applicationBLL.SetSizingMeasure();
string[] AppsToIgnore = Apps_SetQualityIndicators.Concat(Apps_SetSnapshots).Concat(Apps_SetSizingMeasure).ToArray();
return AppsToIgnore;
//Task taskSetSnapshots = new Task(() => applicationBLL.SetSnapshots());
//taskSetSnapshots.Start();
//Task taskQualityIndicators = new Task(() => applicationBLL.SetQualityIndicators());
//taskQualityIndicators.Start();
////Build Quality Indicators
//Task taskSizingMeasure = new Task(() => applicationBLL.SetSizingMeasure());
//taskSizingMeasure.Start();
//taskSetSnapshots.Wait();
//taskQualityIndicators.Wait();
//taskSizingMeasure.Wait();
}
}
/// <summary>
///
/// </summary>
public static void BuildApplicationResult(WSConnection connection, Application application)
{
//Build Quality Indicators
using (ApplicationBLL applicationBLL = new ApplicationBLL(connection, application))
{
Task taskQualityIndicators = new Task(() => applicationBLL.SetQualityIndicators());
taskQualityIndicators.Start();
//Build Quality Indicators
Task taskSizingMeasure = new Task(() => applicationBLL.SetSizingMeasure());
taskSizingMeasure.Start();
taskQualityIndicators.Wait();
taskSizingMeasure.Wait();
}
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <returns></returns>
public static string[] BuildSnapshotResult(WSConnection connection, Snapshot[] snapshot, bool withActionPlan)
{
//Build modules
using (PortfolioSnapshotsBLL snapshotBll = new PortfolioSnapshotsBLL(connection, snapshot))
{
List<string> Snaps_SetModules = snapshotBll.SetModules();
List<string> Snaps_SetQualityIndicators = snapshotBll.SetQualityIndicators();
List<string> Snaps_SetSizingMeasure = snapshotBll.SetSizingMeasure();
List<string> Snaps_SetConfigurationBusinessCriterias = snapshotBll.SetConfigurationBusinessCriterias();
List<string> Snaps_SetComplexity = snapshotBll.SetComplexity();
string[] AllSnapsToIgnore = Snaps_SetComplexity.Concat(Snaps_SetConfigurationBusinessCriterias).Concat(Snaps_SetModules).Concat(Snaps_SetQualityIndicators).Concat(Snaps_SetSizingMeasure).ToArray();
return AllSnapsToIgnore;
}
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <returns></returns>
public static void BuildSnapshotResult(WSConnection connection, Snapshot snapshot, bool withActionPlan)
{
//Build modules
using (SnapshotBLL snapshotBll = new SnapshotBLL(connection, snapshot))
{
Task taskModules = new Task(() => snapshotBll.SetModules());
taskModules.Start();
//Build Quality Indicators
Task taskQualityIndicators = new Task(() => snapshotBll.SetQualityIndicators());
taskQualityIndicators.Start();
//Build Sizing Measures
Task taskSizingMeasure = new Task(() => snapshotBll.SetSizingMeasure());
taskSizingMeasure.Start();
//Build Configuration for Business Criteria
Task taskConfigurationBusinessCriterias = new Task(() => snapshotBll.SetConfigurationBusinessCriterias());
taskConfigurationBusinessCriterias.Start();
//Build Configuration for Business Criteria
Task taskComplexity = new Task(() => snapshotBll.SetComplexity());
taskComplexity.Start();
//build action plan
Task taskAP = null;
if (withActionPlan)
{
taskAP = new Task(() => snapshotBll.SetActionsPlan());
taskAP.Start();
}
taskModules.Wait();
taskQualityIndicators.Wait();
taskSizingMeasure.Wait();
taskConfigurationBusinessCriterias.Wait();
taskComplexity.Wait();
if (taskAP != null) taskAP.Wait();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Setting AddConnection(WSConnection connection, bool isActive, out StatesEnum state)
{
using (ISettingRepository settingRepository = new SettingsRepository())
{
var setting = settingRepository.GetSeting();
if (!CommonBLL.CheckService(connection))
{
state = StatesEnum.ServiceInvalid;
return setting;
}
if (!setting.WSConnections.Any(x => x.Equals(connection)))
{
setting.WSConnections.Add(connection);
}
else
{
state = StatesEnum.ConnectionAlreadyExist;
}
if (isActive)
{
setting.ChangeActiveConnection(connection.Uri.ToString());
state = StatesEnum.ConnectionAddedAndActivated;
}
else
{
state = StatesEnum.ConnectionAddedSuccessfully;
}
settingRepository.SaveSetting(setting);
return setting;
}
}
/// <summary>
///
/// </summary>
/// <param name="snapshotHref"></param>
/// <param name="count"></param>
/// <returns></returns>
///
public IEnumerable<CommonCategories> GetCommonCategories(WSConnection Connection)
{
try
{
using (var castRepsitory = GetRepository(Connection))
{
return castRepsitory.GetCommonCategories();
}
}
catch (Exception ex)
{
return null;
}
}
public string GetCommonCategoriesJson(WSConnection Connection)
{
try
{
using (var castRepsitory = GetRepository(Connection))
{
return castRepsitory.GetCommonCategoriesJson();
}
}
catch (Exception ex)
{
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public ApplicationBLL(WSConnection connection, Application application)
: base(connection)
{
_Application = application;
}
public RuleBLL(WSConnection connection)
: base(connection)
{
}
/// <summary>
/// Implement Add service Command
/// </summary>
private void ExecuteAddCommand(object prameter)
{
try
{
WSConnection conn = new WSConnection(NewConnectionUrl, NewConnectionLogin, NewConnectionPassword, string.Empty);
StatesEnum state;
Setting = SettingsBLL.AddConnection(conn, false, out state);
if (state == StatesEnum.ConnectionAddedAndActivated || state == StatesEnum.ConnectionAddedSuccessfully)
{
WSConnections = new ObservableCollection<WSConnection>(Setting.WSConnections);
NewConnectionUrl = NewConnectionLogin = NewConnectionPassword = string.Empty;
}
base.MessageManager.OnServiceAdded(conn.Url, state);
}
catch (UriFormatException ex)
{
base.MessageManager.OnServiceAdded(NewConnectionUrl, StatesEnum.ServiceInvalid);
}
}
/// <summary>
///
/// </summary>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public PortfolioBLL(WSConnection connection, Application[] application)
: base(connection)
{
_Application = application;
}
/// <summary>
///
/// </summary>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public PortfolioSnapshotsBLL(WSConnection connection, Snapshot[] snapshot)
: base(connection)
{
_Snapshot = snapshot;
}
/// <summary>
///
/// </summary>
/// <param name="application"></param>
/// <param name="connection"></param>
/// <returns></returns>
private static Application GetApplication(string application, WSConnection connection)
{
List<Application> applications;
using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
{
applications = castDomainBLL.GetApplications();
}
return applications.Where(_ => _.Name == application).FirstOrDefault();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Setting RemoveConnection(WSConnection connection)
{
using (ISettingRepository setttingRepository = new SettingsRepository())
{
var setting = setttingRepository.GetSeting();
setting.WSConnections.Remove(connection);
setttingRepository.SaveSetting(setting);
return setting;
}
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
public void ActiveCurrentWebService(WSConnection connection)
{
StatesEnum state;
Setting = SettingsBLL.AddConnection(connection, true, out state);
base.MessageManager.OnServiceAdded(connection.Uri == null ? string.Empty : connection.Uri.ToString(), state);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ActivateWebService_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
{
var list = e.Parameter as List<string>;
if (list != null)
{
var connection = new WSConnection
{
Url = list[0],
Login = list[1],
Password = list[2]
};
(this.DataContext as ReportingVM).ActiveCurrentWebService(connection);
}
(this.DataContext as ReportingVM).InitializeFromWS();
e.Handled = true;
}
/// <summary>
///
/// </summary>
/// <param name="arguments"></param>
/// <param name="help"></param>
/// <returns></returns>
private static string GenerateReport(XmlCastReport arguments, out string help)
{
if (arguments.ReportType != null)
{
string reportPath = string.Empty;
string tmpReportFile = string.Empty;
try
{
help = string.Empty;
//Get RG settings
var settings = SettingsBLL.GetSetting();
LogHelper.Instance.LogInfo("RG settings have been read successfully");
//Initialize temporary directory
string workDirectory = SettingsBLL.GetApplicationPath();
//tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath, arguments.Template.Name));
//tmpReportFile = PathUtil.CreateTempCopy(workDirectory, arguments.Template.Name);
//Initialize Web services
var connection = new WSConnection(arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name, string.Empty);
using (CommonBLL commonBLL = new CommonBLL(connection))
{
if (!commonBLL.CheckService())
{
help = string.Format("Webservice can't be access or is bad formatted. Url:{0} Username:{1} Password:{2}", arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name);
return string.Empty;
}
}
LogHelper.Instance.LogInfo("Web services Initialized successfully");
List<Application> Apps = new List<Application>();
try
{
using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
{
if (arguments.Tag == null)
{
Apps = castDomainBLL.GetCommonTaggedApplications(null);
}
else
{
Apps = castDomainBLL.GetCommonTaggedApplications(arguments.Tag.Name);
}
}
}
catch (Exception ex)
{
LogHelper.Instance.LogInfo("Error occured while trying get applications for the portfolio");
}
Application[] SelectedApps = Apps.ToArray<Application>();
LogHelper.Instance.LogInfo("Applications is the portfolio found successfully");
string[] AppsToIgnorePortfolioResult = PortfolioBLL.BuildPortfolioResult(connection, SelectedApps);
LogHelper.Instance.LogInfo("Build result for the portfolio");
string[] SnapsToIgnore = null;
List<Application> N_Apps = new List<Application>();
//Remove from Array the Ignored Apps
for (int i = 0; i < SelectedApps.Count(); i++)
{
int intAppYes = 0;
foreach (string s in AppsToIgnorePortfolioResult)
{
if (s == SelectedApps[i].Name)
{
intAppYes = 1;
break;
}
else
{
intAppYes = 0;
}
}
if (intAppYes == 0)
{
N_Apps.Add(SelectedApps[i]);
}
}
Application[] N_SelectedApps = N_Apps.ToArray();
List<Snapshot> Snapshots = new List<Snapshot>();
try
{
using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
{
Snapshots = castDomainBLL.GetAllSnapshots(N_SelectedApps);
}
}
catch (Exception ex)
{
LogHelper.Instance.LogInfo("Error occured while trying get snapshots of applications for the portfolio");
}
LogHelper.Instance.LogInfo("Snapshots is the portfolio found successfully");
List<Snapshot> N_Snaps = new List<Snapshot>();
if (Snapshots != null)
{
Snapshot[] SelectedApps_Snapshots = Snapshots.ToArray<Snapshot>();
SnapsToIgnore = PortfolioSnapshotsBLL.BuildSnapshotResult(connection, SelectedApps_Snapshots, true);
LogHelper.Instance.LogInfo("Build result for snapshots in portfolio");
for (int i = 0; i < SelectedApps_Snapshots.Count(); i++)
{
int intRemoveYes = 0;
foreach (string s in SnapsToIgnore)
{
if (s == SelectedApps_Snapshots[i].Href)
{
intRemoveYes = 1;
break;
}
else
{
intRemoveYes = 0;
}
}
if (intRemoveYes == 0)
{
N_Snaps.Add(SelectedApps_Snapshots[i]);
}
}
Snapshot[] N_SelectedApps_Snapshots = N_Snaps.ToArray();
//GenerateReportPortfolio(N_SelectedApps, N_SelectedApps_Snapshots);
//string tmpReportFile = String.Empty;
string tmpReportFileFlexi = String.Empty;
try
{
//Create temporary report
//string workDirectory = SettingsBLL.GetApplicationPath();
//tmpReportFile = PathUtil.CreateTempCopy(workDirectory + "\\Portfolio\\", arguments.Template.Name);
tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath + "\\Portfolio", arguments.Template.Name));
if (tmpReportFile.Contains(".xlsx"))
{
tmpReportFileFlexi = PathUtil.CreateTempCopyFlexi(workDirectory, arguments.Template.Name);
}
//Build report
ReportData reportData = new ReportData();
if (arguments.Category != null && arguments.Tag != null)
{
reportData = new ReportData()
{
FileName = tmpReportFile,
Application = null,
CurrentSnapshot = null,
PreviousSnapshot = null,
RuleExplorer = new RuleBLL(connection),
CurrencySymbol = "$",
Applications = N_SelectedApps,
Category = arguments.Category.Name,
Tag = arguments.Tag.Name,
snapshots = N_SelectedApps_Snapshots,
IgnoresApplications = AppsToIgnorePortfolioResult,
IgnoresSnapshots = SnapsToIgnore
};
}
else if (arguments.Category != null && arguments.Tag == null)
{
reportData = new ReportData()
{
FileName = tmpReportFile,
Application = null,
CurrentSnapshot = null,
PreviousSnapshot = null,
RuleExplorer = new RuleBLL(connection),
CurrencySymbol = "$",
Applications = N_SelectedApps,
Category = arguments.Category.Name,
Tag = null,
snapshots = N_SelectedApps_Snapshots,
IgnoresApplications = AppsToIgnorePortfolioResult,
IgnoresSnapshots = SnapsToIgnore
};
}
else if (arguments.Category == null && arguments.Tag != null)
{
reportData = new ReportData()
{
FileName = tmpReportFile,
Application = null,
CurrentSnapshot = null,
PreviousSnapshot = null,
RuleExplorer = new RuleBLL(connection),
CurrencySymbol = "$",
Applications = N_SelectedApps,
Category = null,
Tag = arguments.Tag.Name,
snapshots = N_SelectedApps_Snapshots,
IgnoresApplications = AppsToIgnorePortfolioResult,
IgnoresSnapshots = SnapsToIgnore
};
}
else
{
reportData = new ReportData()
{
FileName = tmpReportFile,
Application = null,
CurrentSnapshot = null,
PreviousSnapshot = null,
RuleExplorer = new RuleBLL(connection),
CurrencySymbol = "$",
Applications = N_SelectedApps,
Category = null,
Tag = null,
snapshots = N_SelectedApps_Snapshots,
IgnoresApplications = AppsToIgnorePortfolioResult,
IgnoresSnapshots = SnapsToIgnore
};
}
using (IDocumentBuilder docBuilder = BuilderFactory.CreateBuilder(reportData, tmpReportFile))
{
docBuilder.BuildDocument();
}
LogHelper.Instance.LogInfo("Report generated successfully");
//Set filte report
SetFileName(arguments);
if (string.IsNullOrEmpty(settings.ReportingParameter.GeneratedFilePath))
reportPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), arguments.File.Name);
else
reportPath = Path.Combine(settings.ReportingParameter.GeneratedFilePath, arguments.File.Name);
if (tmpReportFile.Contains(".xlsx"))
{
tmpReportFile = tmpReportFileFlexi;
}
//Copy report file to the selected destination
File.Copy(tmpReportFile, reportPath, true);
}
catch (Exception ex)
{
reportPath = String.Empty;
throw (ex);
}
finally
{
if (!String.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
}
}
return reportPath;
}
catch (Exception ex)
{
help = string.Format("An exception occured : {0}", ex);
return string.Empty;
}
finally
{
if (!string.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
}
}
else
{
string tmpReportFile = string.Empty;
try
{
help = string.Empty;
//Get RG settings
var settings = SettingsBLL.GetSetting();
LogHelper.Instance.LogInfo("RG settings have been read successfully");
//Initialize temporary directory
string workDirectory = SettingsBLL.GetApplicationPath();
tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath, arguments.Template.Name));
//Initialize Web services
var connection = new WSConnection(arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name, string.Empty);
using (CommonBLL commonBLL = new CommonBLL(connection))
{
if (!commonBLL.CheckService())
{
help = string.Format("Webservice can't be access or is bad formatted. Url:{0} Username:{1} Password:{2}", arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name);
return string.Empty;
}
}
LogHelper.Instance.LogInfo("Web services Initialized successfully");
//Initialize Application
Application application = GetApplication(arguments.Application.Name, connection);
if (application == null)
{
help = string.Format("Application {0} can't be found.", arguments.Application.Name);
return string.Empty;
}
LogHelper.Instance.LogInfo(string.Format("Application {0} Initialized successfully", arguments.Application.Name));
//Initialize snapshots
SetSnapshots(connection, application);
if (application.Snapshots == null)
{
help = "There is no snapshots for this application.";
return string.Empty;
}
LogHelper.Instance.LogInfo(string.Format("List of Snapshots Initialized successfully", arguments.Application.Name));
//Build Application results
ApplicationBLL.BuildApplicationResult(connection, application);
LogHelper.Instance.LogInfo(string.Format("Application results built successfully", arguments.Application.Name));
//Set current snapshot
Snapshot currentSnapshot = GetSnapshotOrDefault(arguments.Snapshot.Current, application.Snapshots, 0);
if (currentSnapshot == null)
{
help = string.Format("Current snapshot {0} can't be found", arguments.Snapshot.Current.Name);
return string.Empty;
}
LogHelper.Instance.LogInfo(string.Format("Current snapshot {0} initialized successfully", currentSnapshot.Name));
//Build current snapshot results
SnapshotBLL.BuildSnapshotResult(connection, currentSnapshot, true);
LogHelper.Instance.LogInfo(string.Format("Result of current snapshot {0} built successfully", currentSnapshot.Name));
//Set previous snapshot
Snapshot prevSnapshot = GetSnapshotOrDefault(arguments.Snapshot.Previous, application.Snapshots, 1);
if (arguments.Snapshot.Previous != null && !string.IsNullOrEmpty(arguments.Snapshot.Previous.Name) && prevSnapshot == null)
{
help = string.Format("Previous snapshot {0} can't be found", arguments.Snapshot.Previous.Name);
return string.Empty;
}
if (prevSnapshot != null) LogHelper.Instance.LogInfo(string.Format("Previous snapshot {0} Initialized successfully", prevSnapshot.Name));
//Build previous snapshot results
if (prevSnapshot != null)
{
SnapshotBLL.BuildSnapshotResult(connection, prevSnapshot, false);
LogHelper.Instance.LogInfo(string.Format("Result of previous snapshot {0} built successfully", prevSnapshot.Name));
}
//Build report
ReportData reportData = new ReportData()
{
FileName = tmpReportFile,
Application = application,
CurrentSnapshot = currentSnapshot,
PreviousSnapshot = prevSnapshot,
Parameter = settings.ReportingParameter,
RuleExplorer = new RuleBLL(connection),
SnapshotExplorer = new SnapshotBLL(connection, currentSnapshot),
CurrencySymbol = "$"
};
using (IDocumentBuilder docBuilder = BuilderFactory.CreateBuilder(reportData, ""))
{
docBuilder.BuildDocument();
}
LogHelper.Instance.LogInfo("Report generated successfully");
//Set filte report
SetFileName(arguments);
string reportPath;
if (string.IsNullOrEmpty(settings.ReportingParameter.GeneratedFilePath))
reportPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), arguments.File.Name);
else
reportPath = Path.Combine(settings.ReportingParameter.GeneratedFilePath, arguments.File.Name);
File.Copy(tmpReportFile, reportPath, true);
LogHelper.Instance.LogInfo("Report moved to generation directory successfully");
return reportPath;
}
catch (Exception ex)
{
help = string.Format("An exception occured : {0}", ex);
return string.Empty;
}
finally
{
if (!string.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
/// <param name="application"></param>
/// <returns></returns>
private static void SetSnapshots(WSConnection connection, Application application)
{
using (ApplicationBLL applicationBLL = new ApplicationBLL(connection, application))
{
applicationBLL.SetSnapshots();
}
}
/// <summary>
///
/// </summary>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public SnapshotBLL(WSConnection connection, Snapshot snapshot)
: base(connection)
{
_Snapshot = snapshot;
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public BaseBLL(WSConnection connection)
{
Connection = connection;
}
/// <summary>
///
/// </summary>
/// <param name="currentSnapshot"></param>
/// <param name="previousSnapshot"></param>
public CastDomainBLL(WSConnection connection)
: base(connection)
{
}
protected ICastRepsitory GetRepository(WSConnection Connection)
{
return new CastRepository(Connection);
}
