示例#1
0
        private void TryExportBillDemand(MultipleExportBillDemandState multipleExportBillDemandState)
        {
            if (!multipleExportBillDemandState.BillDemandBusinessService.CheckPaymentPlanFilled(multipleExportBillDemandState.InstanceId))
            {
                AddPaymentPlanNotSelectedResult(multipleExportBillDemandState);
            }
            else
            {
                try
                {
                    RaiseExportBillDemand(multipleExportBillDemandState);

                    if (WorkflowStateService.GetCurrentState(multipleExportBillDemandState.InstanceId) == WorkflowState.BillDemandInAccountingWithExport)
                    {
                        AddErrorResult(multipleExportBillDemandState);
                    }
                    else
                    {
                        AddOkResult(multipleExportBillDemandState);
                    }
                }
                catch (Exception ex)
                {
                    AddErrorResult(multipleExportBillDemandState);
                }
            }
        }
示例#2
0
        public List <WorkflowStateInfo> GetAvailiableWorkflowStateToSet(ApiCommandArgument arg)
        {
            var infos = new List <WorkflowStateInfo>();

            AuthenticationService.Authenticate(arg.SecurityToken);

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


            if (!SecurityEntityService.CheckTrusteeWithIdIsInRole(AuthenticationService.GetCurrentIdentity().Id, BudgetRole.FullControl))
            {
                var permissions
                    = SecurityEntityService.GetAlPermissionsForTrusteeAndworkflow(arg.SecurityToken)
                      .Where(p => p.LinkedStateToSet != null)
                      .Select(p => p.LinkedStateToSet);

                if (permissions.Count() < 1)
                {
                    return(infos);
                }
                infos = WorkflowStateService.GetAllAvailiableStates(arg.InstanceId)
                        .Where(i => permissions.Count(p => p.WorkflowStateName == i.StateSystemName && p.Type.Id == i.WorkflowTypeId) > 0)
                        .ToList();
            }
            else
            {
                infos = WorkflowStateService.GetAllAvailiableStates(arg.InstanceId);
            }

            return(infos);
        }
示例#3
0
        public void ExportBillDemand(ApiCommandArgument arg)
        {
            AuthenticationService.Authenticate(arg.SecurityToken);

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

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

            FireCommandWithWaiting(arg, delegate(ApiCommandArgument arg1)
            {
                using (var sync = GetWorkflowSync(arg1))
                {
                    WorkflowInitService.RaiseExport(arg1.InstanceId);
                    sync.WaitHandle.WaitOne(60000);
                }
            });

            var state = WorkflowStateService.GetCurrentState(arg.InstanceId);

            if (state == WorkflowState.BillDemandInAccountingWithExport)
            {
                var errorMessage = WorkflowParcelService.GetAndRemoveMessage(arg.InstanceId);

                throw new FaultException <BaseFault>(new BaseFault((int)ErrorCodes.BillDemandUploadError),
                                                     new FaultReason(string.IsNullOrEmpty(errorMessage) ?
                                                                     "Не удалось выгрузить расходный документ. Попробуйте провести данную операцию еще раз. Если сообщение будет повторятся, обратитесь к Администратору." : errorMessage));
            }
        }
        //TODO Вынести имперсонацию отсюда
        public List <WorkflowCommandType> IsAllowedToExecuteCommand(Guid instanceUid,
                                                                    List <WorkflowCommandType> commandsToCheck)
        {
            var allowedOperations = new List <WorkflowCommandType>(commandsToCheck.Count);

            WorkflowState currentState;

            try
            {
                currentState = WorkflowStateService.GetCurrentState(instanceUid);
            }
            catch (ArgumentException)
            {
                return(allowedOperations);
            }

            WorkflowType workflowType = currentState == null
                                            ? WorkflowStateService.TryGetExpectedWorkflowType(instanceUid)
                                            : currentState.Type;

            if (workflowType == null)
            {
                return(allowedOperations);
            }

            IAuthorizationValidator validator;

            try
            {
                var validatorFactory = new AuthorizationValidatorFactory(workflowType, this);
                validator = validatorFactory.CreateValidator();
            }
            catch (ArgumentException)
            {
                return(allowedOperations);
            }

            var identities = GetAllIdentities();

            if (AuthorizeAccessAndImpersonateIfNecessary(identities, validator, currentState, instanceUid))
            {
                allowedOperations.AddRange(commandsToCheck.Where(commandToCheck => validator.IsCommandSupportsInState(currentState, commandToCheck, instanceUid)));
            }

            //Добавление дополнительных команд специфичных для вф и не привязанных к паре пользователь-состояние

            allowedOperations = validator.AddAdditionalCommand(AuthenticationService.GetCurrentIdentity(), identities, currentState, instanceUid, allowedOperations);

            return(allowedOperations);
        }
示例#5
0
        public List <WorkflowCommandType> GetListOfAllowedOperations(ApiCommandArgument arg)
        {
            var allowedOperations = new List <WorkflowCommandType>();

            AuthenticationService.Authenticate(arg.SecurityToken);

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

            var commandsToCheck = new List <WorkflowCommandType>()
            {
                WorkflowCommandType.StartProcessing,
                WorkflowCommandType.Sighting,
                WorkflowCommandType.Denial,
                WorkflowCommandType.DenialByTechnicalCauses,
                WorkflowCommandType.PostingAccounting,
                WorkflowCommandType.CheckStatus,
                WorkflowCommandType.SetDenialStatus,
                WorkflowCommandType.SetPaidStatus,
                WorkflowCommandType.Export
            };

            allowedOperations = AuthorizationService.IsAllowedToExecuteCommand(arg.InstanceId, commandsToCheck);

            if (!SecurityEntityService.CheckTrusteeWithIdIsInRole(AuthenticationService.GetCurrentIdentity().Id, BudgetRole.FullControl))
            {
                var type = WorkflowStateService.TryGetExpectedWorkflowType(arg.InstanceId);
                if (SecurityEntityService.GetAlPermissionsForTrusteeAndworkflow(arg.SecurityToken)
                    .Count(p => p.LinkedStateToSet != null && p.LinkedStateToSet.Type.Id == type.Id) > 0)
                {
                    allowedOperations.Add(WorkflowCommandType.SetWorkflowState);
                }
            }
            else
            {
                allowedOperations.Add(WorkflowCommandType.SetWorkflowState);
            }


            return(allowedOperations);
        }
        public void SetWorkflowState(Guid instanceId, ServiceIdentity serviceIdentity, string stateName, string comment)
        {
            var workflowState = WorkflowStateService.GetWorkflowState(instanceId);


            if (workflowState.WorkflowStateName != stateName || workflowState.IsInitial)
            //Для черновиков устанавливаем всегда это временно
            {
                WorkflowSupportService.TryUpgradeWorkflow(Runtime, instanceId);

                WorkflowParcelService.AddParcel(instanceId,
                                                new WorkflowSetStateParcel()
                {
                    Comment               = comment,
                    InitiatorId           = serviceIdentity.Id,
                    Command               = WorkflowCommand.Unknown,
                    PreviousWorkflowState = workflowState
                });
                bool isIdled = true;
                using (var sync = new WorkflowSync(Runtime, instanceId))
                {
                    if (!WorkflowSupportService.CreateWorkflowIfNotExists(Runtime, instanceId, workflowState.Type))
                    //Это ожидание создания воркфлоу
                    {
                        sync.WaitHandle.WaitOne(600000);
                        isIdled = sync.WasIdled;
                    }
                }
                //Если воркфлоу не стало идленым - то его необходимо удалить полностью и создать заново
                if (!isIdled)
                {
                    using (var context = this.CreateContext())
                    {
                        context.DeleteWorkflowInPesistenceStore(instanceId);
                        context.SubmitChanges();
                    }
                    using (var sync = new WorkflowSync(Runtime, instanceId))
                    {
                        if (!WorkflowSupportService.CreateWorkflowIfNotExists(Runtime, instanceId, workflowState.Type))
                        //Это ожидание создания воркфлоу
                        {
                            sync.WaitHandle.WaitOne(600000);
                        }
                    }
                }

                var instance         = new StateMachineWorkflowInstance(Runtime, instanceId);
                var newWorkflowState = WorkflowStateService.GetWorkflowState(instanceId);
                if (newWorkflowState.WorkflowStateName != stateName)
                {
                    using (var sync = new WorkflowSync(Runtime, instanceId))
                    //Это ожидание завершения установки состояния воркфлоу
                    {
                        instance.SetState(stateName);
                        sync.WaitHandle.WaitOne(600000);
                    }
                }
                WorkflowState state =
                    WorkflowState.AllStates.First(
                        ws => ws.WorkflowStateName == stateName && ws.Type.Id == workflowState.Type.Id);
                if (!state.IsFinal && !state.IsInitial)
                {
                    WorkflowSupportService.RewriteWorkflow(instanceId, state);
                }
                //Для РД удаляем историю согласования
                if (workflowState.Type == WorkflowType.BillDemandWorkfow)
                {
                    if (state == WorkflowState.BillLimitManagerSighting)
                    {
                        BillDemandBuinessService.LimitExecutorResetSights(instanceId);
                    }

                    BillDemandBuinessService.LimitExecutorResetSights(instanceId);
                    BillDemandBuinessService.LimitManagerResetSights(instanceId);
                }
            }
        }