public override void ExecuteUnderTransaction(JobExecutionContext context)
        {
            logger.Info("Start QueueMailAccountJob....");

            var smtpServer       = context.JobDetail.JobDataMap["SmtpServer"] != null ? context.JobDetail.JobDataMap["SmtpServer"].ToString() : string.Empty;
            var fromEmailAddress = context.JobDetail.JobDataMap["FromEmailAddress"] != null ? context.JobDetail.JobDataMap["FromEmailAddress"].ToString() : string.Empty;
            var bccEmailAddress  = context.JobDetail.JobDataMap["BccEmailAddress"] != null ? context.JobDetail.JobDataMap["BccEmailAddress"].ToString() : string.Empty;

            if (string.IsNullOrEmpty(smtpServer) || string.IsNullOrEmpty(fromEmailAddress))
            {
                throw new NullReferenceException("QueueMailAccountJob: fromEmailAddress and smtpServer must not be null");
            }

            var accountQueueMailService = (IAccountQueueMailService)ServiceLocator.Current.GetService(typeof(IAccountQueueMailService));

            if (accountQueueMailService == null)
            {
                throw new NullReferenceException("accountQueueMailService must not be null");
            }

            var accountMailQueues = accountQueueMailService.GetAccountMailQueueByStatus(QueueStatusTypeEnum.CREATED);

            using (var workflowRuntime = new WorkflowRuntime())
            {
                workflowRuntime.AddService(new TerminateHelperService());

                using (var manager = new WorkflowRuntimeManager(workflowRuntime))
                {
                    manager.MessageEvent += manager_MessageEvent;

                    for (var i = 0; i < accountMailQueues.Count; i++)
                    {
                        var wfArguments = new Dictionary <string, object> {
                            { "AccountMailQueueId", accountMailQueues[i].Id },
                            { "SmtpServer", smtpServer },
                            { "FromEmailAddress", fromEmailAddress },
                            { "BccEmailAddress", bccEmailAddress }
                        };
                        var wrapper  = manager.StartWorkflow(typeof(MailAccountWorkflow), wfArguments);
                        var waitTest = manager.WaitOne(wrapper.Id, 30000);

                        if (wrapper.Exception != null)
                        {
                            logger.Error(wrapper.Exception.Message);
                        }
                    }

                    manager.WaitAll(300000);
                    manager.ClearAllWorkflows();
                }
            }
        }
Beispiel #2
0
        public override void ExecuteUnderTransaction(JobExecutionContext context)
        {
            logger.Info("Start ChargingOrderJob....");

            var paymentUrlProvider       = context.JobDetail.JobDataMap["PaymentUrlProvider"].ToString();
            var backupPaymentUrlProvider = context.JobDetail.JobDataMap["BackupPaymentUrlProvider"].ToString();

            var orderService = (IOrderService)ServiceLocator.Current.GetService(typeof(IOrderService));

            if (orderService == null)
            {
                throw new NullReferenceException("orderService must not be null");
            }

            var orders = orderService.GetOrdersByStatus(OrderStatusEnum.Verified);

            using (var workflowRuntime = new WorkflowRuntime())
            {
                workflowRuntime.AddService(new TerminateHelperService());

                using (var manager = new WorkflowRuntimeManager(workflowRuntime))
                {
                    manager.MessageEvent += manager_MessageEvent;

                    for (var i = 0; i < orders.Count; i++)
                    {
                        var wfArguments = new Dictionary <string, object> {
                            { "OrderId", orders[i].Id },
                            { "PaymentProviderUrl", paymentUrlProvider },
                            { "BackupPaymentProviderUrl", backupPaymentUrlProvider }
                        };
                        var wrapper  = manager.StartWorkflow(typeof(ChargingOrderWorkflow), wfArguments);
                        var testWait = manager.WaitOne(wrapper.Id, 30000);

                        if (wrapper.Exception != null)
                        {
                            logger.Error(wrapper.Exception.Message);
                        }
                    }

                    manager.WaitAll(300000);
                    manager.ClearAllWorkflows();
                }
            }
        }
Beispiel #3
0
        public static void Run()
        {
            Console.WriteLine("Running test configured with App.Config");

            using (WorkflowRuntimeManager manager
                       = new WorkflowRuntimeManager(
                             new WorkflowRuntime("WorkflowRuntime")))
            {
                //add event handler to log messages from the manager
                manager.MessageEvent += delegate(
                    Object sender, WorkflowLogEventArgs e)
                {
                    Console.WriteLine(e.Message);
                };

                //start the workflow runtime. It will also autostart if
                //we don't do it here.
                manager.WorkflowRuntime.StartRuntime();

                //create a dictionary with input arguments
                Dictionary <String, Object> wfArguments
                    = new Dictionary <string, object>();
                wfArguments.Add("InputString", "one");
                //run the workflow
                manager.StartWorkflow(
                    typeof(SharedWorkflows.Workflow1), wfArguments);

                //run another instance with different parameters
                wfArguments.Clear();
                wfArguments.Add("InputString", "two");
                manager.StartWorkflow(
                    typeof(SharedWorkflows.Workflow1), wfArguments);

                //run another instance with different parameters
                wfArguments.Clear();
                wfArguments.Add("InputString", "three");
                manager.StartWorkflow(
                    typeof(SharedWorkflows.Workflow1), wfArguments);

                //wait for all workflow instances to complete
                manager.WaitAll(15000);

                //display the results from all workflow instances
                foreach (WorkflowInstanceWrapper wrapper
                         in manager.Workflows.Values)
                {
                    if (wrapper.OutputParameters.ContainsKey("Result"))
                    {
                        Console.WriteLine(wrapper.OutputParameters["Result"]);
                    }
                    else
                    {
                        //must be a problem - see if there is an exception
                        if (wrapper.Exception != null)
                        {
                            Console.WriteLine("{0} - Exception: {1}",
                                              wrapper.Id, wrapper.Exception.Message);
                        }
                    }
                }
                manager.ClearAllWorkflows();
            }
        }
Beispiel #4
0
        public static void Run()
        {
            Console.WriteLine("Running test of WorkflowInstance methods");

            using (WorkflowRuntimeManager manager
                       = new WorkflowRuntimeManager(
                             new WorkflowRuntime("WorkflowRuntime")))
            {
                //add event handler to log messages from the manager
                manager.MessageEvent += delegate(
                    Object sender, WorkflowLogEventArgs e)
                {
                    Console.WriteLine(e.Message);
                };

                //start the workflow runtime. It will also autostart if
                //we don't do it here.
                manager.WorkflowRuntime.StartRuntime();

                //create a dictionary with input arguments
                Dictionary <String, Object> wfArguments
                    = new Dictionary <string, object>();
                wfArguments.Add("InputString", "one");
                //run the workflow
                WorkflowInstanceWrapper instance = manager.StartWorkflow(
                    typeof(SharedWorkflows.Workflow1), wfArguments);

                //manually terminate the workflow instance
                instance.WorkflowInstance.Terminate("Manually terminated");
                //wait for this instance to end
                instance.WaitHandle.WaitOne(10000, false);

                //run another instance with different parameters
                wfArguments.Clear();
                wfArguments.Add("InputString", "two");
                instance = manager.StartWorkflow(
                    typeof(SharedWorkflows.Workflow1), wfArguments);
                //give the workflow time to start execution
                System.Threading.Thread.Sleep(1000);

                //suspend the workflow
                instance.WorkflowInstance.Suspend("Manually suspended");
                //now resume the workflow we just suspended
                instance.WorkflowInstance.Resume();
                //wait for the instance to end
                instance.WaitHandle.WaitOne(10000, false);

                //display the results from all workflow instances
                foreach (WorkflowInstanceWrapper wrapper
                         in manager.Workflows.Values)
                {
                    if (wrapper.OutputParameters.ContainsKey("Result"))
                    {
                        Console.WriteLine(wrapper.OutputParameters["Result"]);
                    }
                    //must be a problem - see if there is an exception
                    if (wrapper.Exception != null)
                    {
                        Console.WriteLine("{0} - Exception: {1}",
                                          wrapper.Id, wrapper.Exception.Message);
                    }
                    //was it suspended?
                    if (wrapper.ReasonSuspended.Length > 0)
                    {
                        Console.WriteLine("{0} - Suspended: {1}",
                                          wrapper.Id, wrapper.ReasonSuspended);
                    }
                }
                manager.ClearAllWorkflows();
            }
        }