/// <summary>
/// Set taskanswer for a receive-task
/// </summary>
/// <param name="taskId">Id of the task</param>
/// <param name="messageInstanceId">Id of the choosen message</param>
/// <param name="username">username</param>
public void submitReceiveTaskAnswer(int taskId, string messageInstanceId, string username)
{
IProcessStore processStore = StoreHandler.getProcessStore(connectionString);
ITaskStore taskStore = StoreHandler.getTaskStore(connectionString);
T_Task openTask = taskStore.getTaskById(taskId);
//check if task isn't already answered
if (openTask.Done == false && openTask.Type.Equals("R"))
{
P_ProcessSubject processSubject = processStore.getProcessSubjectForWFId(openTask.WFId);
P_Process process = processStore.getProcess(processSubject.Process_Id);
DynamicValue val = new DynamicValue();
val.Add("MessageId", new DynamicValue(messageInstanceId));
submitTaskAnswer(val, process, openTask);
//set task as answered
//taskStore.setTaskStatus(taskId, true);
taskStore.setTaskStatus(taskId, username, "", messageInstanceId);
//set the owner of the task recipient instance to the user who submitted the taskanswer
processStore.setWorkflowInstanceOwner(openTask.WFId, username);
}
}
public string addProcess(string companyScopeName, string processScopeName, string workflow_MessageTier_Path, List <SubjectConfig> processSubjects, bool createDBEntries, string startSubjectname, int WS_Project_Id, int WS_Project_Version, string processInfo)
{
string scope = createProcessScope(companyScopeName, processScopeName);
WorkflowManagementClient client = new WorkflowManagementClient(new Uri(cfgWFMBaseAddress + companyScopeName + "/" + processScopeName + "/"), credentials);
client.PublishWorkflow(workflow_MessageTier_Name, workflow_MessageTier_Path,
new MatchAllSubscriptionFilter() //Filter
{
Matches =
{
{ "NotificationType", "NewMessage" }
}
});
foreach (SubjectConfig process in processSubjects)
{
if (process.Xaml != null)
{
client.PublishWorkflowString(process.Name, process.Xaml);
}
}
if (createDBEntries)
{
IProcessStore processStore = StoreHandler.getProcessStore(cfgSQLConnectionString);
P_Process newProcess = new P_Process(processScopeName);
newProcess.WS_ProjectId = WS_Project_Id;
newProcess.WS_Project_Version = WS_Project_Version;
newProcess.WFM_ProcessScope = processScopeName;
newProcess.ProcessInfo = processInfo;
newProcess.WFM_RootScope = companyScopeName + "/";
newProcess.ProcessSubjects = new List <P_ProcessSubject>();
foreach (SubjectConfig process in processSubjects)
{
if (process.Xaml != null)
{
newProcess.ProcessSubjects.Add(new P_ProcessSubject(process.Name, process.Name.Equals(startSubjectname), process.Name, process.Role_Id, process.MultiSubject));
}
else
{
newProcess.ProcessSubjects.Add(new P_ProcessSubject(process.Name, process.Name.Equals(startSubjectname), null, process.Role_Id, process.MultiSubject));
}
}
processStore.addNewProcess(newProcess);
}
return(scope);
}
/// <summary>
/// start a new instance of a processsubject with an existing processinstanceid
/// </summary>
/// <param name="processInstanceId">existing processinstanceid</param>
/// <param name="subjectProcessId">id of the processsubject</param>
/// <param name="username">owner of the new processsubject instance</param>
/// <returns>id of the new workflow instance</returns>
public string startNewSubjectProcess(string processInstanceId, int subjectProcessId, string username)
{
IProcessStore processStore = StoreHandler.getProcessStore(connectionString);
Console.WriteLine("start2 " + subjectProcessId + " " + username);
P_ProcessSubject subject = processStore.getProcessSubject(subjectProcessId);
P_Process process = processStore.getProcess(subject.Process_Id);
string adress = baseAddress + process.WFM_RootScope + process.WFM_ProcessScope;
WorkflowManagementClient client = new WorkflowManagementClient(new Uri(adress), credentials);
string guid = client.Workflows.Start(subject.WFM_WFName);
processStore.addWorkflowInstance(subject.Id, processInstanceId, guid, username);
Console.WriteLine(guid, ConsoleColor.Blue);
return(guid);
}
public void CustomInit(P_Process process)
{
this.p_process = process;
processTitle.Content = $"{process.process.ProcessName} ({process.process.Id})";
if (p_process != null && !String.IsNullOrEmpty(p_process.alias))
{
txtAlias.Text = process.alias;
}
else
{
txtAlias.Text = process.process.Id.ToString();
}
this.doMonitor.IsChecked = process.doMonitor;
}
protected override void Execute(CodeActivityContext context)
{
IProcessStore processStore = StoreHandler.getProcessStore(context.GetValue(cfgSQLConnectionString));
P_WorkflowInstance senderInstance = processStore.getWorkflowInstance(context.GetValue(SenderId));
P_ProcessSubject senderProcessSubject = processStore.getProcessSubject(senderInstance.ProcessSubject_Id);
P_Process process = processStore.getProcess(senderProcessSubject.Process_Id);
P_ProcessSubject recipientProcessSubject = processStore.getProcessSubject(senderProcessSubject.Process_Id, context.GetValue(RecipientSubject));
//check if message is for internal subject
if (recipientProcessSubject.WFM_WFName != null)
{
string recipientuser = context.GetValue(RecipientUsername);
if (recipientuser != null)
{
if (recipientuser.Length == 0)
{
recipientuser = null;
}
}
P_WorkflowInstance recipientInstance = processStore.getWorkflowInstance(recipientProcessSubject.Id, senderInstance.ProcessInstance_Id, recipientuser);
if (recipientInstance != null)
{
//update recipient workflow id
context.SetValue(RecipientId, recipientInstance.Id);
}
//message is for internal subject
context.SetValue(IsMessageForExternalSubject, false);
//update recipient processsubjectId
context.SetValue(RecipientProcessSubjectId, recipientProcessSubject.Id);
}
else
{
//message is for external subject
context.SetValue(IsMessageForExternalSubject, true);
}
context.SetValue(GlobalProcessName, process.GlobalProcessName);
context.SetValue(ProcessInstanceId, senderInstance.ProcessInstance_Id);
context.SetValue(SenderSubject, senderProcessSubject.Name);
context.SetValue(SenderUsername, senderInstance.Owner);
context.SetValue(Recipient_Role_Id, recipientProcessSubject.U_Role_Id);
}
private void submitTaskAnswer(DynamicValue val, P_Process process, T_Task openTask)
{
//create and publish notification
WorkflowManagementClient client = new WorkflowManagementClient(new Uri(baseAddress + process.WFM_RootScope + process.WFM_ProcessScope), credentials);
client.PublishNotification(new WorkflowNotification()
{
Properties =
{
{ "NotificationType", "taskAnswer" },
{ "wfID", openTask.WFId },
{ "OrderId", openTask.InternalOrderId }
},
Content = new Dictionary <string, object>()
{
{ "data", val }
}
});
}
/// <summary>
/// Set taskanswer for a send-state task
/// </summary>
/// <param name="taskId">Id of the task</param>
/// <param name="recipientName">choosen recipient/s</param>
/// <param name="editableParameters">edited parameters</param>
public void submitSendTaskAnswer(int taskId, string recipientName, string editableParameters, string username)
{
IProcessStore processStore = StoreHandler.getProcessStore(connectionString);
ITaskStore taskStore = StoreHandler.getTaskStore(connectionString);
T_Task openTask = taskStore.getTaskById(taskId);
//check if task isn't already answered
if (openTask.Done == false && openTask.Type.Equals("S"))
{
P_ProcessSubject processSubject = processStore.getProcessSubjectForWFId(openTask.WFId);
P_Process process = processStore.getProcess(processSubject.Process_Id);
DynamicValue val = DynamicValue.Parse(editableParameters);
val.Add("recipient", new DynamicValue(recipientName));
submitTaskAnswer(val, process, openTask);
//set task as answered
//taskStore.setTaskStatus(taskId, true);
taskStore.setTaskStatus(taskId, username, editableParameters, recipientName);
}
}
public void addNewProcess(P_Process p)
{
db.P_Processes.Add(p);
db.SaveChanges();
}
static void Main(string[] args)
{
string postUrl = "";
string processToMonitor = "";
int intervalMS = 10000;
int rotationalNotifyTime = 600000; //600000; // in ms
intervalMS = int.Parse(ConfigurationManager.AppSettings["pollingIntervalMS"]);
rotationalNotifyTime = int.Parse(ConfigurationManager.AppSettings["rotationNotifyTimeMS"]);
postUrl = ConfigurationManager.AppSettings["SlackURL"];
processToMonitor = ConfigurationManager.AppSettings["ProcessName"];
CultureInfo culture = new CultureInfo("en-GB");
Notifier.setDestinationUrl(postUrl);
Notifier.start(rotationalNotifyTime); //10 min
Process[] localAll = Process.GetProcessesByName(processToMonitor);
List <Process> sortedProcesses = new List <Process>(localAll);
sortedProcesses.Sort((x, y) => x.StartTime.CompareTo(y.StartTime));
List <P_Process> monitored_processes = new List <P_Process>();
string StartMessage = "Starting Monitoring:\n";
foreach (var process in sortedProcesses)
{
StartMessage += $"{process.Id} which started at {process.StartTime}\n";
Console.WriteLine($"Adding ({process.ProcessName})[{process.StartTime}] ({process.Id}) to monitor");
ETWwrapper.addProcess(process.Id);
P_Process monitoredProcess = new P_Process();
monitoredProcess.process = process;
monitoredProcess.data_processor = new DataProcessor(intervalMS, 6, process.Id, rotationalNotifyTime / 10000);
monitored_processes.Add(monitoredProcess);
}
StartMessage += ":good-luck: :good-luck: :good-luck: :good-luck: :good-luck: :good-luck: :good-luck: :good-luck: :good-luck:";
Notifier.Notify(StartMessage);
string logName = $"{processToMonitor}_{DateTime.Now.Day}_{DateTime.Now.Month}__{DateTime.Now.Hour}_{DateTime.Now.Minute}.csv";
Console.WriteLine($"Writting to {logName}\nConfigurations:");
var appSettings = ConfigurationManager.AppSettings;
foreach (var key in appSettings.AllKeys)
{
Console.WriteLine("{0}={1}", key, appSettings[key]);
}
Log.Start(logName);
ETWwrapper.start();
string header = "Time";
foreach (var process in monitored_processes)
{
header += $",S({process.process.Id}),R({process.process.Id})";
}
Log.Write(header);
while (!UserCancelled())
{
string outputData = "";
outputData += $"{DateTime.Now.ToString(culture)}";
foreach (var process in monitored_processes)
{
SessionData somedata = ETWwrapper.getData(process.process.Id);
process.data_processor.Append(somedata);
double milliseconds_passed_since_data = DateTime.Now.Subtract(somedata.timestamp).TotalMilliseconds;
if (milliseconds_passed_since_data > intervalMS)
{
outputData += $",{0},{0}";
}
else
{
outputData += $",{somedata.sent},{somedata.received}";
}
}
Log.Write(outputData);
Thread.Sleep(intervalMS);
}
}
public bool publishActiveProcesses(List <int> processIdToInclude = null)
{
Process[] localAll = Process.GetProcessesByName(StateManager.m_config.ProcessName);
bool monitoredProcessesChanged = false;
lock (StateManager.monitoredProcessesMutex)
{
// remove dead processes
foreach (var monitored_process in StateManager.monitored_processes.ToList())
{
bool monitored_process_is_alive = false;
// clear processes that are not exist anymore
foreach (var process_ in localAll)
{
if (process_.Id == monitored_process.process.Id)
{
// process still alive
monitored_process_is_alive = true;
break;
}
}
if (!monitored_process_is_alive)
{
// monitored process is dead, should remove it from list
ETWwrapper.removeProcess(monitored_process.process.Id);
StateManager.monitored_processes.Remove(monitored_process);
monitoredProcessesChanged = true;
}
}
foreach (var process in localAll)
{
bool isMonitored = false;
foreach (var monitored_process in StateManager.monitored_processes.ToList())
{
if (process.Id == monitored_process.process.Id)
{
// this process already monitored skip
isMonitored = true;
break;
}
}
if (isMonitored)
{
//this process already monitored continue to next process
continue;
}
if (processIdToInclude == null || (processIdToInclude != null && processIdToInclude.Contains(process.Id)))
{
// this is a new process which we should add to the list to monitor
P_Process monitoredProcess = new P_Process();
monitoredProcess.doMonitor = true;
monitoredProcess.process = process;
monitoredProcess.monitorStartTime = DateTime.Now;
monitoredProcess.data_processor = new DataProcessor(process.Id);
StateManager.monitored_processes.Add(monitoredProcess);
ETWwrapper.addProcess(process.Id);
//sort the monitored processes according to their start time
StateManager.monitored_processes.Sort((x, y) => x.process.StartTime.CompareTo(y.process.StartTime));
monitoredProcessesChanged = true;
}
}
}
return(monitoredProcessesChanged);
}
public void Dispose()
{
p_process = null;
}
