public override void Start()
{
DeserializationFilter deserializationFilter = new DeserializationFilter();
deserializationFilter.UseLegacyCollection = this.IsLegacyCollection;
ServiceMapFilter serviceMapFilter = new ServiceMapFilter(this);
WsdlFilter wsdlFilter = new WsdlFilter();
ContextFilter contextFilter = new ContextFilter(this);
AuthenticationFilter authenticationFilter = new AuthenticationFilter(this);
DescribeServiceFilter describeServiceFilter = new DescribeServiceFilter();
//CacheFilter cacheFilter = new CacheFilter();
ProcessFilter processFilter = new ProcessFilter(this);
MessageFilter messageFilter = new MessageFilter(this);
DebugFilter debugFilter = new DebugFilter();
SerializationFilter serializationFilter = new SerializationFilter();
serializationFilter.UseLegacyCollection = this.IsLegacyCollection;
serializationFilter.UseLegacyThrowable = this.IsLegacyThrowable;
deserializationFilter.Next = serviceMapFilter;
serviceMapFilter.Next = wsdlFilter;
wsdlFilter.Next = contextFilter;
contextFilter.Next = authenticationFilter;
authenticationFilter.Next = describeServiceFilter;
describeServiceFilter.Next = processFilter;
//describeServiceFilter.Next = cacheFilter;
//cacheFilter.Next = processFilter;
processFilter.Next = debugFilter;
debugFilter.Next = messageFilter;
messageFilter.Next = serializationFilter;
_filterChain = new FilterChain(deserializationFilter);
}
public Task <ActionResult <ProcessModel> > GetProcess(
ProcessFilter processFilter)
{
return(InvokeForProcess <ProcessModel>(
processInfo => ProcessModel.FromProcessInfo(processInfo),
processFilter));
}
public override void Start()
{
DeserializationFilter filter = new DeserializationFilter {
UseLegacyCollection = this.GetIsLegacyCollection()
};
ServiceMapFilter filter2 = new ServiceMapFilter(this);
WsdlFilter filter3 = new WsdlFilter();
AuthenticationFilter filter4 = new AuthenticationFilter(this);
DescribeServiceFilter filter5 = new DescribeServiceFilter();
ProcessFilter filter6 = new ProcessFilter(this);
MessageFilter filter7 = new MessageFilter(this);
DebugFilter filter8 = new DebugFilter();
SerializationFilter filter9 = new SerializationFilter {
UseLegacyCollection = this.GetIsLegacyCollection()
};
filter.Next = filter2;
filter2.Next = filter3;
filter3.Next = filter4;
filter4.Next = filter5;
filter5.Next = filter6;
filter6.Next = filter8;
filter8.Next = filter7;
filter7.Next = filter9;
this._filterChain = new FilterChain(filter);
}
private string BuildUserQueryClause(ProcessFilter filter, bool needsCreate, bool needsLastChange)
{
var queryBuilder = new StringBuilder();
queryBuilder.AppendLine("SELECT DISTINCT P.[PROCESS_ID] AS ProcessId");
queryBuilder.AppendLine("FROM RAA.dbo.PROCESS P");
queryBuilder.AppendLine("INNER JOIN (SELECT DEFN_PROCESS_ID FROM RAA.dbo.DEFN_PROCESS WHERE DOC_TYPE_NAME IN @docTypeList) D on P.DEFN_PROCESS_ID = D.DEFN_PROCESS_ID");
if (NeedsCriteria(filter.ActorIdList))
{
queryBuilder.AppendLine("INNER JOIN (");
queryBuilder.AppendLine(" SELECT PROCESS_ID");
queryBuilder.AppendLine(" FROM ACTOR ACT");
queryBuilder.AppendLine(" INNER JOIN ACTIVITY A ON ACT.ACTIVITY_ID = A.ACTIVITY_ID");
if (NeedsCriteria(filter.ActivityStateList))
{
queryBuilder.AppendLine(" AND STATE IN @activityStateList");
}
queryBuilder.AppendLine(" WHERE ACT.HANFORD_ID IN @actorList");
queryBuilder.AppendLine(" ) R ON P.PROCESS_ID = R.PROCESS_ID");
}
if (NeedsCriteria(filter.OriginatorIdList) || NeedsCriteria(filter.BeneficiaryIdList) || needsCreate || needsLastChange || NeedsCriteria(filter.ProcessStateList))
{
queryBuilder.AppendLine(" WHERE ");
List <string> clauses = new List <string>();
if (NeedsCriteria(filter.ProcessStateList))
{
clauses.Add("P.STATE in @processStateList");
}
if (NeedsCriteria(filter.OriginatorIdList))
{
clauses.Add("P.DOC_ORIGINATOR_ID in @originatorId");
}
if (NeedsCriteria(filter.BeneficiaryIdList))
{
clauses.Add("P.DOC_BENEFICIARY_ID in @beneficiaryId");
}
if (needsCreate)
{
clauses.Add("P.CREATE_DATETIME between @createStart and @createEnd");
}
if (needsLastChange)
{
clauses.Add("P.LAST_CHANGE_DATETIME between @lastChangeStart and @lastChangeEnd");
}
queryBuilder.Append(string.Join(" AND ", clauses));
}
return(queryBuilder.ToString());
}
public void ContainsWithSinglePattern()
{
ProcessFilter f = new ProcessFilter("session");
Assert.AreEqual(true, f.Contains("RBCWSSession"));
Assert.AreEqual(true, f.Contains("some session server"));
Assert.AreEqual(false, f.Contains("Quake"));
Assert.AreEqual(false, f.Contains(""));
}
private void ProcessTerminatedHandler(IRunningProcess aProcess)
{
if (!ProcessFilter.ForInvalidProcesses(_platformBits).IsValid(aProcess))
{
return;
}
RemoveRunningProcess(aProcess);
RemoveProcessHooks(aProcess);
}
public void ContainsWithMultiplePatterns()
{
ProcessFilter f = new ProcessFilter("Session,UserInfo");
Assert.AreEqual(true, f.Contains("RBCWSUserInfo"));
Assert.AreEqual(true, f.Contains("Some Session Server"));
Assert.AreEqual(true, f.Contains("Some Userinfo App"));
Assert.AreEqual(false, f.Contains("Quake"));
Assert.AreEqual(false, f.Contains(""));
}
private List <string> BuildTypeList(ProcessFilter processFilter)
{
if (processFilter.DocumentTypeList != null && processFilter.DocumentTypeList.Count > 0)
{
return(processFilter.DocumentTypeList);
}
else
{
return(null);
}
}
public Task <ActionResult <ProcessModel> > GetProcess(
ProcessFilter processFilter)
{
return(this.InvokeService <ProcessModel>(async() =>
{
IProcessInfo processInfo = await _diagnosticServices.GetProcessAsync(
processFilter,
HttpContext.RequestAborted);
return ProcessModel.FromProcessInfo(processInfo);
}));
}
public Task <ActionResult <ProcessModel> > GetProcess(
ProcessFilter processFilter)
{
return(InvokeForProcess <ProcessModel>(processInfo =>
{
ProcessModel processModel = ProcessModel.FromProcessInfo(processInfo);
_logger.WrittenToHttpStream();
return processModel;
},
processFilter));
}
private DynamicParameters BuildOriginatorParameters(ProcessFilter processFilter, IList <string> activityStateList, IList <string> processStateList, IList <string> typeList, IList <string> originatorList, IList <string> beneficiaryList)
{
DynamicParameters parameters = new DynamicParameters();
if (NeedsCriteria(processFilter.ActorIdList))
{
parameters.Add("actorList", processFilter.ActorIdList);
}
if (NeedsCriteria(processFilter.DocumentTypeList))
{
parameters.Add("docTypeList", processFilter.DocumentTypeList);
}
if (activityStateList != null)
{
parameters.Add("activityStateList", activityStateList);
}
if (processStateList != null)
{
parameters.Add("processStateList", processStateList);
}
if (originatorList != null)
{
parameters.Add("originatorId", originatorList);
}
if (beneficiaryList != null)
{
parameters.Add("beneficiaryId", beneficiaryList);
}
if (processFilter.CreateDateRange != null)
{
parameters.Add("createStart", processFilter.CreateDateRange.Start);
parameters.Add("createEnd", processFilter.CreateDateRange.End);
}
if (processFilter.CreateDateRange != null)
{
parameters.Add("lastChangeStart", processFilter.LastChangeDateRange.Start);
parameters.Add("lastChangeEnd", processFilter.LastChangeDateRange.End);
}
return(parameters);
}
private List <string> BuildActivityStateList(ProcessFilter processFilter)
{
List <string> stateList = null;
if (processFilter.ActivityStateList != null && processFilter.ActivityStateList.Count > 0)
{
stateList = new List <string>();
foreach (ActivityState state in processFilter.ActivityStateList)
{
stateList.Add(state.Name);
}
}
return(stateList);
}
private void DisplayRunningProcesses()
{
var processes = _spyManager.RunningProcesses();
processes = ProcessFilter.ForInvalidProcesses(_platformBits).Filter(processes);
var clasifier = new ProcessClasifier();
clasifier.Categorize(processes.Cast <IProcess>());
_view.DisplayRunningProcesses(
clasifier.ToHookOnStart.ToArray(),
clasifier.UnHooked.ToArray(),
clasifier.HookedInactive.ToArray(),
clasifier.HookedActive.ToArray());
}
private void ProcessStartedHandler(IRunningProcess aProcess)
{
if (!ProcessFilter.ForInvalidProcesses(_platformBits).IsValid(aProcess))
{
return;
}
_view.DisplayNewRunningProcess(aProcess);
_view.RemoveProcessToBeHookedOnStart(aProcess);
UpdateProcessToSelectionIfItsGroupIsSelected(aProcess);
DisplaySelectedProcessesModulesIfWasAdded(aProcess);
_hookLoader.LoadHooksOn(new [] { aProcess });
}
private List <string> BuildProcessStateList(ProcessFilter processFilter)
{
List <string> processStateList = null;
if (processFilter.ProcessStateList != null && processFilter.ProcessStateList.Count > 0)
{
processStateList = new List <string>();
foreach (ProcessState state in processFilter.ProcessStateList)
{
processStateList.Add(state.Name);
}
}
return(processStateList);
}
public void ImportHookingSettings(Stream exportedHookingSettings)
{
try
{
var importedSettings = HookingSettings.FromXml(exportedHookingSettings);
_hookingSettings.AddRulesFrom(importedSettings);
}
catch
{
_view.ShowError("Cannot import hooking settings. The file is invalid.");
return;
}
var processes = ProcessFilter.ForInvalidProcesses(_platformBits).Filter(_spyManager.RunningProcesses());
_hookLoader.LoadHooksOn(processes);
}
private static DynamicParameters BuildActorParameters(ProcessFilter processFilter, IList <string> activityStateList, IList <string> processStateList, IList <string> typeList, IList <string> originatorList, IList <string> beneficiaryList)
{
DynamicParameters parameters = new DynamicParameters();
// only required field
parameters.Add("actorHanfordId", processFilter.ActorIdList[0]);
if (typeList != null)
{
parameters.Add("docTypeList", typeList.ToArray());
}
if (activityStateList != null)
{
parameters.Add("activityStateList", activityStateList);
}
if (processStateList != null)
{
parameters.Add("processStateList", processStateList);
}
if (originatorList != null)
{
parameters.Add("originatorId", originatorList);
}
if (beneficiaryList != null)
{
parameters.Add("beneficiaryId", beneficiaryList);
}
if (processFilter.CreateDateRange != null)
{
parameters.Add("createStart", processFilter.CreateDateRange.Start);
parameters.Add("createEnd", processFilter.CreateDateRange.End);
}
if (processFilter.CreateDateRange != null)
{
parameters.Add("lastChangeStart", processFilter.LastChangeDateRange.Start);
parameters.Add("lastChangeEnd", processFilter.LastChangeDateRange.End);
}
return(parameters);
}
public Task <ActionResult <Dictionary <string, string> > > GetProcessEnvironment(
ProcessFilter processFilter)
{
return(InvokeForProcess <Dictionary <string, string> >(processInfo =>
{
var client = new DiagnosticsClient(processInfo.EndpointInfo.Endpoint);
try
{
return client.GetProcessEnvironment();
}
catch (ServerErrorException)
{
throw new InvalidOperationException("Unable to get process environment.");
}
},
processFilter));
}
public Task <ActionResult <Dictionary <string, string> > > GetProcessEnvironment(
ProcessFilter processFilter)
{
return(this.InvokeService <Dictionary <string, string> >(async() =>
{
IProcessInfo processInfo = await _diagnosticServices.GetProcessAsync(
processFilter,
HttpContext.RequestAborted);
try
{
return processInfo.Client.GetProcessEnvironment();
}
catch (ServerErrorException)
{
throw new InvalidOperationException("Unable to get process environment.");
}
}));
}
public override void Start()
{
DeserializationFilter deserializationFilter = new DeserializationFilter();
deserializationFilter.UseLegacyCollection = GetIsLegacyCollection();
ServiceMapFilter serviceMapFilter = new ServiceMapFilter(this);
ProcessFilter processFilter = new ProcessFilter(this);
MessageFilter messageFilter = new MessageFilter(this);
SerializationFilter serializationFilter = new SerializationFilter();
serializationFilter.UseLegacyCollection = GetIsLegacyCollection();
deserializationFilter.Next = serviceMapFilter;
serviceMapFilter.Next = processFilter;
processFilter.Next = messageFilter;
messageFilter.Next = serializationFilter;
_filterChain = new FilterChain(deserializationFilter);
}
public async Task SearchAsync_ReturnsValidRequest_GivenValidLimit()
{
ProcessFilter validFilter = new ProcessFilter();
int validLimit = 1;
int validOffset = 0;
List <Process> returnList = new List <Process>
{
new Process()
{
ProcessId = 1
}
};
PagedResult <Process> result = new PagedResult <Process>(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), returnList);
_mockProcessFacade // arrange
.Setup(store => store.SearchAsync(It.IsAny <ProcessFilter>(), It.IsAny <Person>(), It.Is <int?>(s => s == validOffset), It.Is <int?>(s => s == validLimit), It.IsAny <CancellationToken>(), It.IsAny <IDictionary <object, object> >()))
.ReturnsAsync(result);
using (var controller = InstanceProcessController(_mockProcessFacade))
{
var actual = await controller.FilterAsync(It.IsAny <List <string> >(),
It.IsAny <List <string> >(),
It.IsAny <List <string> >(),
It.IsAny <List <ActorActionTaken> >(),
It.IsAny <List <string> >(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <int?>(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <int?>(),
It.IsAny <List <string> >(),
It.IsAny <List <string> >(),
validOffset, validLimit); // act
CommonAsserts(actual, StatusCodes.Status200OK); // assert
var objectResult = actual as ObjectResult;
Assert.IsNotNull(objectResult?.Value as PagedResult <Process>);
}
}
private async Task <List <string> > BuildLOriginatorList(ProcessFilter processFilter)
{
List <string> originatorList = null;
if (processFilter.OriginatorIdList != null && processFilter.OriginatorIdList.Count > 0)
{
originatorList = new List <string>();
foreach (string originator in processFilter.OriginatorIdList)
{
originatorList.Add(originator);
var person = await _personIdentificationStore.GetByHanfordIdAsync(originator);
originatorList.Add(person.EmployeeId);
}
}
return(originatorList);
}
private async Task <List <string> > BuildLBeneficiaryList(ProcessFilter processFilter)
{
List <string> beneficiaryList = null;
if (processFilter.BeneficiaryIdList != null && processFilter.BeneficiaryIdList.Count > 0)
{
beneficiaryList = new List <string>();
foreach (string beneficiary in processFilter.BeneficiaryIdList)
{
beneficiaryList.Add(beneficiary);
var person = await _personIdentificationStore.GetByHanfordIdAsync(beneficiary);
beneficiaryList.Add(person.EmployeeId);
}
}
return(beneficiaryList);
}
/// <summary>
/// Asynchronously searches the <see cref="Process"/> store based on the filter criteria with security based on the actor is the user
/// </summary>
/// <param name="processFilter">The filter criteria to apply to the result set.</param>
/// <param name="limit">Maximun number of items that we are going to return per page.</param>
/// <param name="offset">Number of pages that will be skipped.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A dictionary of ChargeCodeInfo objects.</returns>
public virtual async Task <PagedResult <Process> > SearchWithActorAsync(ProcessFilter processFilter, int offset, int limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
cancellationToken.ThrowIfCancellationRequested();
if (processFilter == null)
{
throw new ArgumentNullException(nameof(processFilter));
}
if (offset < 0)
{
throw new ArgumentException($"{nameof(offset)} must be a positive integer!");
}
if (limit <= 0)
{
throw new ArgumentException($"{nameof(limit)} must be a positive integer!");
}
return(await OnSearchWithActorAsync(processFilter, offset, limit, cancellationToken, context ?? new Dictionary <object, object>()));
}
/// <summary>
/// Asynchronously retrieves a list of <see cref="Process"/>.
/// </summary>
/// <param name="processFilter">The filter criteria to apply to the result set.</param>
/// <param name="limit">Maximun number of items that we are going to return per page.</param>
/// <param name="offset">Number of pages that will be skipped.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A <see cref="Task{TResult}"/> </returns>
protected override async Task <PagedResult <Process> > OnSearchWithUserAsync(ProcessFilter processFilter, int offset, int limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
try
{
IList <string> activityStateList = BuildActivityStateList(processFilter);
IList <string> processStateList = BuildProcessStateList(processFilter);
IList <string> typeList = BuildTypeList(processFilter);
IList <string> originatorList = await BuildLOriginatorList(processFilter);
IList <string> beneficiaryList = await BuildLBeneficiaryList(processFilter);
string query = BuildUserQueryClause(processFilter, processFilter.CreateDateRange != null, processFilter.LastChangeDateRange != null);
DynamicParameters parameters = BuildUserParameters(processFilter, activityStateList, processStateList, typeList, originatorList, beneficiaryList);
return(await ExecuteSearch(offset, limit, context, query, parameters, cancellationToken));
}
catch (Exception ex)
{
_logger.LogError($"Unable to retrieve process list. Reason: {ex}");
throw;
}
}
public void SmokeTest()
{
// Instantiating the objects.
ILogger logger = new ConsoleLogger();
SeriesFilter sf = new SeriesFilter();
sf.AddDesiredSeries("%ProcessorTime",
"PlotComPlus.Series.DefaultSeries");
sf.AddDesiredSeries("PrivateBytes",
"PlotComPlus.Series.MemorySeries");
IProcessFilter pf = new ProcessFilter("session,userinfo");
LogParser parser = new LogParser(pf, sf, logger);
// Setting up the test log file.
string path = Path.GetTempFileName();
string[] content = new string[] {
"Microsoft (R) Windows Script Host Version 5.6",
"Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.",
"",
"Time,CN,PN(ID),%ProcessorTime,%UT,TC,PrivateBytes,WS",
"4/3/2007 10:00:37 AM,.,Idle(0),100,0,8,0,16384",
"4/3/2007 10:00:37 AM,.,System(4),0,0,110,28672,28672",
"4/3/2007 10:00:37 AM,.,RBCWSSession(6520),23,0,31,30208000,37974016",
",,,,,,,",
"4/3/2007 10:00:42 AM,.,RBCWSSession(6520),24,0,31,25071616,34078720",
"4/3/2007 10:00:42 AM,.,RBCWSUserInfo(10496),11,0,32,13414400,21475328",
"4/4/2007,.,RBCWSSession(6520),25,0,31,25214976,34222080"
};
File.WriteAllLines(path, content);
// Now we run the smoke test of parsing 1 log file containing
// 2 processes (RBCWSSession, RBCWSUserInfo) we are interested,
// with the 2 metrics above that we are interested in.
List <Process> processes = parser.ParseLogs(path);
Assert.AreEqual(2, processes.Count);
Process session = processes[0];
Assert.AreEqual("RBCWSSession", session.ProcessName);
Assert.AreEqual(3, session.TimeSeries.Count);
IList <double> data = session.Get("%ProcessorTime");
Assert.AreEqual(3, data.Count);
Assert.AreEqual(true, data.Contains(23f));
Assert.AreEqual(true, data.Contains(24f));
Assert.AreEqual(true, data.Contains(25f));
data = session.Get("PrivateBytes");
Assert.AreEqual(3, data.Count);
Assert.AreEqual(true, data.Contains(30.208d));
Assert.AreEqual(true, data.Contains(25.071616d));
Assert.AreEqual(true, data.Contains(25.214976d));
Process userinfo = processes[1];
Assert.AreEqual("RBCWSUserInfo", userinfo.ProcessName);
Assert.AreEqual(1, userinfo.TimeSeries.Count);
data = userinfo.Get("%ProcessorTime");
Assert.AreEqual(1, data.Count);
Assert.AreEqual(true, data.Contains(11d));
data = userinfo.Get("PrivateBytes");
Assert.AreEqual(1, data.Count);
Assert.AreEqual(true, data.Contains(13.4144d));
// Clean up.
File.Delete(path);
}
/// <summary>
/// Asynchronously retrieves a list of <see cref="Activity"/>.
/// </summary>
/// <param name="processFilter">The filter criteria to apply to the result set.</param>
/// <param name="limit">Maximun number of items that we are going to return per page.</param>
/// <param name="offset">Number of pages that will be skipped.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A <see cref="Task{TResult}"/> </returns>
protected abstract Task <PagedResult <Process> > OnSearchWithUserAsync(ProcessFilter processFilter, int offset, int limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null);
public static int Main(string[] args)
{
string patterns = null;
string logFiles = null;
string outputPath = null;
OutputType outputChoice = 0;
List <string> helps = new List <string>(
new string[] { "--help", "-h", "/?", "/HELP", "-help" });
foreach (string arg in args)
{
if (helps.Contains(arg))
{
ShowHelp();
return(1);
}
}
switch (args.Length)
{
case 1:
// Valid case:
// plot_complus.exe log_file.txt
logFiles = args[0];
outputChoice = OutputType.Interactive;
break;
case 2:
// Valid case:
// plot_complus.exe log_file.txt process_filter
logFiles = args[0];
patterns = args[1];
outputChoice = OutputType.Interactive;
break;
case 3:
// Valid cases:
// plot_complus.exe log_file.txt -o out_graph.png
// plot_complus.exe log_file.txt -a out_dir
if (args[1] == "-o" || args[1] == "-a")
{
logFiles = args[0];
outputChoice = (args[1] == "-o" ?
OutputType.File : OutputType.Directory);
outputPath = args[2];
break;
}
else
{
Console.WriteLine("Invalid arguments {0}!", args[1]);
return(1);
}
case 4:
// Valid case:
// plot_complus.exe log_file.txt process_filter -o out_graph.png
if (args[2] == "-o")
{
logFiles = args[0];
patterns = args[1];
outputChoice = OutputType.File;
outputPath = args[3];
break;
}
else
{
Console.WriteLine("Invalid arguments {0}!", args[2]);
return(1);
}
default:
Console.WriteLine("Wrong number of input arguments!");
return(1);
}
IProcessFilter processFilter;
if (patterns != null)
{
processFilter = new ProcessFilter(patterns);
}
else
{
processFilter = new AllProcesses();
}
ILogger logger = new ConsoleLogger();
SeriesFilter seriesFilter = new SeriesFilter();
List <string[]> tupleList = Settings.DesiredSeries(
ConfigurationManager.AppSettings);
foreach (string[] seriesTuple in tupleList)
{
seriesFilter.AddDesiredSeries(seriesTuple[0], seriesTuple[1]);
}
GraphPlotter plotter = new GraphPlotter(seriesFilter);
LogParser parser = new LogParser(processFilter, seriesFilter, logger);
List <Process> processes = parser.ParseLogs(logFiles);
switch (outputChoice)
{
case OutputType.Directory:
outputPath = Path.GetFullPath(outputPath);
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
Dictionary <string, List <Process> > processGroup =
new Dictionary <string, List <Process> >();
foreach (Process p in processes)
{
if (!processGroup.ContainsKey(p.ProcessName))
{
processGroup[p.ProcessName] = new List <Process>();
}
processGroup[p.ProcessName].Add(p);
}
foreach (KeyValuePair <string, List <Process> > pair in processGroup)
{
string path = Path.Combine(outputPath, pair.Key + DEFAULT_EXT);
plotter.WriteToFile(pair.Value, path);
}
break;
case OutputType.File:
outputPath = Path.GetFullPath(outputPath);
string ext = Path.GetExtension(outputPath).ToLower();
if (ext.Length > 0)
{
if (!VALID_EXTS.Contains(ext))
{
Console.WriteLine("The graph cannot be saved in {0}!" +
" Will save it in {1} instead.", ext, DEFAULT_EXT);
outputPath = Path.GetFileNameWithoutExtension(outputPath)
+ DEFAULT_EXT;
}
}
else
{
Console.WriteLine("The graph will be saved in {0}.", DEFAULT_EXT);
outputPath = Path.GetFileNameWithoutExtension(outputPath)
+ DEFAULT_EXT;
}
plotter.WriteToFile(processes, outputPath);
break;
case OutputType.Interactive:
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(plotter, processes));
break;
}
return(0);
}
public ProcessFilter GenerateProcessFilter(int?offset,
int?limit,
List <string> actorIds = null,
List <string> orginatorIds = null,
List <string> beneficaryIds = null,
List <ActorActionTaken> actionTakenList = null,
List <string> activityStateNames = null,
DateTime?createDateStart = null,
DateTime?createDateEnd = null,
int?createDays = null,
DateTime?lastDateStart = null,
DateTime?lastDateEnd = null,
int?lastDays = null,
List <string> docTypeNames = null,
List <string> processStateNames = null,
IDictionary <object, object> context = null)
{
try
{
ProcessFilter processFilter = new ProcessFilter();
if (actorIds != null && actorIds.Count > 0)
{
processFilter.ActorIdList = actorIds;
}
if (orginatorIds != null && orginatorIds.Count > 0)
{
processFilter.OriginatorIdList = orginatorIds;
}
if (beneficaryIds != null && beneficaryIds.Count > 0)
{
processFilter.BeneficiaryIdList = beneficaryIds;
}
if (actionTakenList != null && actionTakenList.Count > 0)
{
processFilter.ActionTakenList = actionTakenList;
}
if (activityStateNames != null && activityStateNames.Count > 0)
{
processFilter.ActivityStateList = new List <ActivityState>();
foreach (string status in activityStateNames)
{
// don't like this but ...
if (status.ToUpper() == ActivityState.Complete.Name.ToUpper())
{
processFilter.ActivityStateList.Add(ActivityState.Complete);
}
else if (status.ToUpper() == ActivityState.Pending.Name.ToUpper())
{
processFilter.ActivityStateList.Add(ActivityState.Pending);
}
else if (status.ToUpper() == ActivityState.Escalated.Name.ToUpper())
{
processFilter.ActivityStateList.Add(ActivityState.Escalated);
}
}
}
if (processStateNames != null && processStateNames.Count > 0)
{
processFilter.ProcessStateList = new List <ProcessState>();
foreach (string state in processStateNames)
{
if (state.ToUpper() == ProcessState.Approved.Name.ToUpper())
{
processFilter.ProcessStateList.Add(ProcessState.Approved);
}
else if (state.ToUpper() == ProcessState.Pending.Name.ToUpper())
{
processFilter.ProcessStateList.Add(ProcessState.Pending);
}
else if (state.ToUpper() == ProcessState.Terminated.Name.ToUpper())
{
processFilter.ProcessStateList.Add(ProcessState.Terminated);
}
else if (state.ToUpper() == ProcessState.NotYetPending.Name.ToUpper())
{
processFilter.ProcessStateList.Add(ProcessState.NotYetPending);
}
}
}
if (createDateStart != null && createDateEnd != null)
{
processFilter.CreateDateRange = new DateRange(createDateStart.GetValueOrDefault(), createDateEnd.GetValueOrDefault());
}
else
{
if (createDays != null)
{
processFilter.CreateDateRange = new DateRange(createDays.GetValueOrDefault());
}
}
if (lastDateStart != null && lastDateEnd != null)
{
processFilter.LastChangeDateRange = new DateRange(lastDateStart.GetValueOrDefault(), lastDateEnd.GetValueOrDefault());
}
else
{
if (lastDays != null)
{
processFilter.LastChangeDateRange = new DateRange(lastDays.GetValueOrDefault());
}
}
if (docTypeNames != null && docTypeNames.Count > 0)
{
processFilter.DocumentTypeList = docTypeNames;
}
return(processFilter);
}
catch (Exception exception)
{
_logger.LogInformation($"Error generating the process filter. Reason: {exception}");
throw;
}
}
/// <summary>
/// Asynchronously retrieves the currently available resources.
/// </summary>
/// <param name="processFilter">The list of process identification numbers that we are going to retrieve.</param>
/// <param name="user">The user that is making the request for information.</param>
/// <param name="limit">Maximun number of items that we are going to return per page.</param>
/// <param name="offset">Number of pages that will be skipped.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A dictionary of process objects.</returns>
public async Task <PagedResult <Process> > SearchAsync(ProcessFilter processFilter, Person user, int?offset, int?limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
if (limit > 100)
{
throw new ArgumentException("Limit must be less that 100!");
}
limit = limit ?? 50;
offset = offset ?? 0;
if (processFilter.ProcessStateList == null || processFilter.ProcessStateList.Count == 0)
{
processFilter.ProcessStateList = new List <ProcessState>
{
ProcessState.Approved,
ProcessState.NotYetPending,
ProcessState.Pending,
ProcessState.Terminated
};
}
if (processFilter.ActorIdList != null && processFilter.ActorIdList.Count == 1 && processFilter.ActorIdList[0] == user.Id)
{
// since we are seaching on actor, we can improve performance by filtering out the nulls in the activity states
// because they won't have a corresponding actor record. so if the list is empty we can all the other states
if (processFilter.ActivityStateList == null)
{
processFilter.ActivityStateList = new List <ActivityState>();
}
if (processFilter.ActivityStateList.Count == 0)
{
processFilter.ActivityStateList.Add(ActivityState.Complete);
processFilter.ActivityStateList.Add(ActivityState.Escalated);
processFilter.ActivityStateList.Add(ActivityState.Pending);
}
_logger.LogInformation($"Pnnl.Api.Approvals: User {user.Id} is executing search for actor for {processFilter.ToString()}.");
return(await _processStore.SearchWithActorAsync(processFilter, offset.GetValueOrDefault(), limit.GetValueOrDefault(), cancellationToken, context));
}
else if (processFilter.OriginatorIdList != null && processFilter.OriginatorIdList.Count == 1 && processFilter.OriginatorIdList[0] == user.Id)
{
_logger.LogInformation($"Pnnl.Api.Approvals: User {user.Id} is executing search for originator for {processFilter.ToString()}.");
return(await _processStore.SearchWithOriginatorAsync(processFilter, offset.GetValueOrDefault(), limit.GetValueOrDefault(), cancellationToken, context));
}
else if (processFilter.BeneficiaryIdList != null && processFilter.BeneficiaryIdList.Count == 1 && processFilter.BeneficiaryIdList[0] == user.Id)
{
_logger.LogInformation($"Pnnl.Api.Approvals: User {user.Id} is executing search for beneficiary for {processFilter.ToString()}.");
return(await _processStore.SearchWithOriginatorAsync(processFilter, offset.GetValueOrDefault(), limit.GetValueOrDefault(), cancellationToken, context));
}
else
{
// get read list
var readTypeList = await _securityStore.GetReadDocumentTypesAsync(user);
if (processFilter.DocumentTypeList != null && processFilter.DocumentTypeList.Count > 0)
{
// intersect with searched doctypes and update filter object
var accessList = processFilter.DocumentTypeList.Intersect(readTypeList);
processFilter.DocumentTypeList = accessList.ToList <string>();
}
else
{
processFilter.DocumentTypeList = (List <string>)readTypeList;
}
_logger.LogInformation($"Pnnl.Api.Approvals: User {user.Id} is executing search by user for {processFilter.ToString()}.");
return(await _processStore.SearchWithUserAsync(processFilter, offset.GetValueOrDefault(), limit.GetValueOrDefault(), cancellationToken, context));
}
}
