Пример #1
0
        public void StartProcessing(ApiCommandArgument arg)
        {
            AuthenticationService.Authenticate(arg.SecurityToken);

            if (!AuthenticationService.IsAuthenticated())
            {
                return;
            }

            if (!AuthorizationService.IsAllowedToExecuteCommand(arg.InstanceId, WorkflowCommandType.StartProcessing))
            {
                return;
            }

            WorkflowInitService.CreateWorkflowIfNotExists(arg.InstanceId);

            using (var sync = GetWorkflowSync(arg))
            {
                sync.WaitHandle.WaitOne(4000);
            }

            FireCommandWithWaiting(arg, delegate(ApiCommandArgument arg1)
            {
                using (var sync = GetWorkflowSync(arg1))
                {
                    WorkflowInitService.RaiseStartProcessing(arg1.InstanceId);
                    sync.WaitHandle.WaitOne(4000);
                }
            });
        }
Пример #2
0
        private void TryRaiseCommand(MultipleExportState multipleExportState)
        {
            if (multipleExportState.CommandToExecute != WorkflowCommandType.SetWorkflowState &&
                !multipleExportState.AuthorizationService.IsAllowedToExecuteCommand(multipleExportState.InstanceId,
                                                                                    multipleExportState.CommandToExecute))
            {
                AddErrorResult(multipleExportState);
            }
            else
            {
                try
                {
                    switch (multipleExportState.CommandToExecute)
                    {
                    case WorkflowCommandType.Sighting:
                        RaiseAction(multipleExportState, WorkflowInitService.RaiseSighting);
                        break;

                    case WorkflowCommandType.StartProcessing:
                        WorkflowInitService.CreateWorkflowIfNotExists(multipleExportState.InstanceId);
                        using (var sync = GetWorkflowSync(multipleExportState.InstanceId))
                        {
                            sync.WaitHandle.WaitOne(4000);
                        }
                        RaiseAction(multipleExportState, WorkflowInitService.RaiseStartProcessing);
                        break;

                    case WorkflowCommandType.Denial:
                        RaiseActionWithComment(multipleExportState, WorkflowInitService.RaiseDenial);
                        break;

                    case WorkflowCommandType.Rollback:
                        RaiseActionWithComment(multipleExportState, WorkflowInitService.RaiseRollback);
                        break;

                    case WorkflowCommandType.SetWorkflowState:
                        RaiseSetStateAction(multipleExportState);
                        break;

                    default:
                        throw new ActionNotSupportedException();
                    }
                }
                catch (Exception ex)
                {
                    AddErrorResult(multipleExportState);
                    throw;
                }

                AddOkResult(multipleExportState);
            }
        }