/// <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; }