public void CreateReport(Stream stream, RuleProfile profile, IEnumerable <IRule> rules, IEnumerable <Result> results, Release release)
{
var ds = (new DataSetGeneator()).Create(profile, rules, results, release, false);
using (var p = new ExcelPackage())
{
var releaseWs = p.Workbook.Worksheets.Add("ReleaseInfo");
LoadCollection(ds.RunProperties, releaseWs, "ReleaseInfoTable", 0, true);
var rulesWs = p.Workbook.Worksheets.Add("Rules");
LoadCollection(ds.RuleResults, rulesWs, "RulesTable", 0, true);
var resultsWs = p.Workbook.Worksheets.Add("Results");
LoadCollection(ds.Results, resultsWs, "ResultsTable", 0);
var summaryWs = p.Workbook.Worksheets.Add("Summary");
CreateResultsPivot(summaryWs, resultsWs.Tables["ResultsTable"]);
var dataItemsWs = p.Workbook.Worksheets.Add("DataItems");
LoadCollection(ds.DataItems, dataItemsWs, "DataItemsTable", 0);
var elementsWs = p.Workbook.Worksheets.Add("Elements");
LoadCollection(ds.Elements, elementsWs, "ElementsTable", 0);
var actionsWs = p.Workbook.Worksheets.Add("Actions");
LoadCollection(ds.Actions, actionsWs, "ActionsTable", 0);
var navigationsWs = p.Workbook.Worksheets.Add("Navigations");
LoadCollection(ds.Navigations, navigationsWs, "NavigationTable", 0);
var exceptionsWs = p.Workbook.Worksheets.Add("Exceptions");
LoadCollection(ds.Exceptions, exceptionsWs, "ExceptionsTable", 0);
p.SaveAs(stream);
}
}
public dynamic Create(RuleProfile profile, IEnumerable <IRule> rules, IEnumerable <Result> results, Release release, bool groupRuleResult)
{
var units = release.GetAnalysisUnits();
var result = new
{
RunProperties = GetRunProperites(release, profile),
RuleResults = GetRuleResults(rules, results),
DataItems = GetVariableData(units),
Actions = units.Where(i => i.Stage.Type == "Action").Select(i => new {
ParentType = i.ParentType,
Parent = i.ParentName,
Page = i.Page,
Stage = i.Stage.Name,
Object = ((ActionStage)i.Stage).Resource.Object,
Action = ((ActionStage)i.Stage).Resource.Action
}),
Elements = GetElements(release),
Exceptions = GetExceptionDetails(units),
Navigations = GetNavigateStages(units),
Results = groupRuleResult ? GetGroupedRules(rules, results) : results.Select(i => new {
RuleName = i.RuleName,
Type = i.Type,
Message = i.Message,
Scope = i.Scope,
Parent = i.Parent,
Page = i.Page,
Stage = i.Stage,
StageType = i.StageType,
StageId = i.StageId
}).ToList(),
};
return(result);
}
private static void GetReport(ConsoleSwitches arguments, ReleaseExtractor extractor, BPRunner bpRunner)
{
var profile = RuleProfile.LoadFromFile();
var rules = bpRunner.GetRulesFromProfile(profile);
var results = bpRunner.RunProfile(profile, extractor.Release);
var report = new ExcelOutputGenerator();
report.CreateReport(arguments.ReportFile.FullName, profile, rules, results, extractor.Release);
}
private string SaveReport(RuleProfile profile, IEnumerable <IRule> rules, IEnumerable <Result> results, Release release)
{
var fileName = (!string.IsNullOrWhiteSpace(release.Name) ? release.Name : @"result") + ".xlsx";
//var fileInfo = new FileInfo(fileName);
release.GetAnalysisUnits();
ExcelOutputGenerator excelGenerator = new ExcelOutputGenerator();
excelGenerator.CreateReport(Path.GetDirectoryName(_fileName) + @"\" + fileName, profile, rules, results, release);
return(fileName);
}
public IEnumerable <IRule> GetRulesFromProfile(RuleProfile profile)
{
var rules = new List <IRule>();
foreach (var ruleConfig in profile.Rules)
{
var file = GetAbsolutePath(ruleConfig.AssemblyFile);
var ass = Assembly.LoadFile(file);
rules.AddRange(GetAllRules(ass));
}
return(rules);
}
private object ExecuteRules()
{
var profile = RuleProfile.LoadFromFile();
var ruleEngine = new BPRunner();
ruleEngine.RuleRun += RuleEngine_RuleRun;
var rules = ruleEngine.GetRulesFromProfile(profile);
var results = ruleEngine.RunRules(profile, _release, rules.ToList());
Reports.RunReport(() => { return(SaveReport(profile, rules, results, _release)); });
return(null);
}
private void CleanReleaseFromProfileExclusions(RuleProfile profile, Release release)
{
foreach (var exclusion in profile.Exclusions)
{
var item = release.Objects.FirstOrDefault(i => i.Name == exclusion.Name);
if (item == null)
{
continue;
}
release.Objects.Remove(item);
item = null;
}
}
private string SaveReport(RuleProfile profile, IEnumerable <IRule> rules, IEnumerable <Result> results, Release release)
{
var fileName = GetExcelFileName();
if (string.IsNullOrWhiteSpace(fileName))
{
return(null);
}
var fileInfo = new FileInfo(fileName);
new ExcelOutputGenerator().CreateReport(fileInfo.FullName, profile, rules, results, release);
return(fileName);
}
private string GetAbsolutePath(string fileName)
{
var fileInfo = new FileInfo(Path.Combine(RuleProfile.GetRuleDir().FullName, fileName));
if (!fileInfo.Exists)
{
fileInfo = new FileInfo(Path.Combine(Environment.CurrentDirectory, fileName));
if (!fileInfo.Exists)
{
throw new InvalidOperationException(string.Format("File {0} in profile not found", fileInfo.Name));
}
}
return(fileInfo.FullName);
}
private object AddRule()
{
var dialog = new OpenFileDialog()
{
Title = "Add files required for the rules",
Filter = "DLL (*.dll)|*.dll",
CheckFileExists = true,
Multiselect = true
};
var ruleDir = RuleProfile.GetRuleDir();
if (!ruleDir.Exists)
{
ruleDir.Create();
}
if (dialog.ShowDialog() == DialogResult.Cancel)
{
return(null);
}
var files = dialog.FileNames.Select(i => new FileInfo(i)).ToList();
foreach (var file in files)
{
var newFile = new FileInfo(Path.Combine(ruleDir.FullName, file.Name));
var over = false;
if (newFile.Exists)
{
over = MessageBox.Show(string.Format("File {0} has been already imported, do you want to override?", file.Name), "File Exists", MessageBoxButtons.YesNo) == DialogResult.Yes;
}
File.Copy(file.FullName, newFile.FullName, over);
}
var rules = new List <string>();
foreach (var file in files)
{
if (HasRule(file.Name))
{
rules.Add(file.Name);
}
}
if (!rules.Any())
{
MessageBox.Show("The files provided doesn't contain rules");
files.ForEach(i => File.Delete(Path.Combine(ruleDir.FullName, i.Name)));
return(null);
}
RegisterRule(rules);
return(null);
}
public MainExec(string filename)
{
_fileName = filename;
_profile = RuleProfile.LoadFromFile();
_profile.Rules = _profile.Rules.Distinct().ToList();
_profile.Save();
if (!File.Exists(_fileName))
{
throw new FileNotFoundException(string.Format("File {0} could not be found", _fileName));
}
var extractor = new ReleaseExtractor(File.ReadAllText(_fileName));
extractor.Load();
_release = extractor.Release;
}
public static IEnumerable <object> GetRunProperites(Release release, RuleProfile profile)
{
var units = release.GetAnalysisUnits();
var res = new List <dynamic>
{
new { Parameter = "Run At UTC", Value = DateTime.UtcNow.ToString("yyyy-MM-dd hh:mm:ss") },
new { Parameter = "Run At Local Time", Value = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss") },
new { Parameter = "Run On Machine", Value = Environment.MachineName },
new { Parameter = "Run By User", Value = Environment.UserName },
new { Parameter = "Profile Exclusions", Value = string.Join("*", profile.Exclusions.Select(i => i.Name)) },
new { Parameter = "Package Name", Value = release.PackageName },
new { Parameter = "Release Name", Value = release.Name },
new { Parameter = "Object Count", Value = release.Objects.Count.ToString() },
new { Parameter = "Process Count", Value = release.Processes.Count.ToString() },
new { Parameter = "Total Stages", Value = units.Count().ToString() }
};
return(res);
}
private void GetReportStream(Stream inputFile, MemoryStream outputSream)
{
var xml = default(string);
using (var streamReader = new StreamReader(inputFile))
{
xml = streamReader.ReadToEnd();
}
var extractor = new ReleaseExtractor(xml);
extractor.Load();
var bpRunner = new BPRunner();
var profile = RuleProfile.LoadFromFile();
var rules = new RuleExtractor().GetRulesFromAssembly(typeof(StageHelper).Assembly);
var results = bpRunner.RunProfile(profile, extractor.Release);
var report = new ExcelOutputGenerator();
report.CreateReport(outputSream, profile, rules, results, extractor.Release);
}
private void lnkAddNewProfile_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
var newProfileName = GetPromptTextInput("Enter a profile name.", "Enter a profile name.");
if (string.IsNullOrWhiteSpace(newProfileName))
{
return;
}
string newProfileId = Guid.NewGuid().ToString();
RuleProfile profile = new RuleProfile
{
Id = newProfileId,
Name = newProfileName,
Rules = new List <FilterRule>()
};
_userSettings.RuleProfiles.Add(profile);
_userSettings.SelectedProfileId = newProfileId;
DrawUi();
}
public IEnumerable <Result> RunRules(RuleProfile profile, Release release, IList <IRule> rules)
{
CleanReleaseFromProfileExclusions(profile, release);
var res = new List <Result>();
foreach (var rule in rules)
{
var msg = string.Format("Running {0} {1} out of {2}", rule.Name, rules.IndexOf(rule) + 1, rules.Count);
try
{
OnRuleRun(new RunnerMessageEventArgs(msg));
res.AddRange(rule.Execute((XmlItem)release));
}
catch (Exception ex)
{
OnRuleRun(new RunnerMessageEventArgs(string.Format("Failed to run rule", rule.Name)));
throw new Exception(string.Format("Unable to run rule: {0}\n{1}", rule.Name, ex.Message), ex);
}
}
OnRuleRun(new RunnerMessageEventArgs("Completed"));
return(res);
}
public IEnumerable <IRule> GetRulesFromProfile(RuleProfile profile)
{
var ruleExtractor = new RuleExtractor();
return(ruleExtractor.GetRulesFromProfile(profile));
}
public IEnumerable <Result> RunProfile(RuleProfile profile, Release release)
{
return(RunRules(profile, release, new RuleExtractor().GetRulesFromAssembly(typeof(StageHelper).Assembly).ToList()));
}
private void Rules_Load(object sender, EventArgs e)
{
fileName.Width = -2;
_profile = RuleProfile.LoadFromFile();
LoadRules();
}
public void CreateReport(string fileName, RuleProfile profile, IEnumerable <IRule> rules, IEnumerable <Result> results, Release release)
{
CreateReport((new StreamWriter(fileName)).BaseStream, profile, rules, results, release);
}
public Rule(string name, bool enabled, RuleDirection direction, RuleProfile profile, string grouping, string localIPAddress,
string localPort, string remoteIPAddress, string remotePort, string protocol, string edgeTraversal, RuleAction action,
RuleInterfaceType interfaceType, RuleSecurity security, string source, string description, string program, string service)
{
Name = name;
Enabled = enabled;
Direction = direction;
Profile = profile;
if (Profile == RuleProfile.Any)
{
Profiles = "Any";
}
else
{
var profiles = new List <string>();
if (IsDomainProfile)
{
profiles.Add("Domain");
}
if (IsPrivateProfile)
{
profiles.Add("Private");
}
if (IsPublicProfile)
{
profiles.Add("Public");
}
Profiles = string.Join(",", profiles.ToArray());
}
Grouping = LoadIndirectString(grouping);
LocalIPAddress = localIPAddress;
LocalPort = localPort;
RemoteIPAddress = remoteIPAddress;
RemotePort = remotePort;
Protocol = protocol;
EdgeTraversal = edgeTraversal;
switch (edgeTraversal.ToLowerInvariant())
{
case "yes":
EdgeTraversalPolicy = RuleEdgeTraversalPolicy.Yes;
break;
case "no":
EdgeTraversalPolicy = RuleEdgeTraversalPolicy.No;
break;
case "defer to user":
EdgeTraversalPolicy = RuleEdgeTraversalPolicy.DeferUser;
break;
case "defer to application":
EdgeTraversalPolicy = RuleEdgeTraversalPolicy.DeferApp;
break;
}
Action = action;
InterfaceType = interfaceType;
Security = security;
Source = source;
Description = description;
Program = program;
Service = service;
}
public IEnumerable <Result> RunProfile(RuleProfile profile, Release release)
{
return(RunRules(profile, release, GetRulesFromProfile(profile).ToList()));
}
