private void AddStepsToRoute(IApprovalRuleBase rule,
                                     List <Structures.ApprovalRuleCardReport.ConditionTableLine> linedRoute,
                                     List <List <Structures.ApprovalRuleCardReport.Transition> > blocks)
        {
            var addedBlocks   = new List <List <Structures.ApprovalRuleCardReport.Transition> >();
            var orderedBlocks = blocks.OrderByDescending(b => string.Join(string.Empty,
                                                                          b.Select(s => string.Format("{0}{1}",
                                                                                                      s.SourceStage,
                                                                                                      s.ConditionValue != false))));

            foreach (var block in orderedBlocks)
            {
                // Убрать дубли.
                var isDuplicate = false;
                foreach (var addedBlock in addedBlocks)
                {
                    isDuplicate = isDuplicate || block.SequenceEqual(addedBlock);
                }

                if (isDuplicate)
                {
                    continue;
                }

                // Условия.
                var conditionsBlocks = block.Where(b => rule.Conditions.Any(n => n.Number == b.SourceStage)).ToList();
                var hasCondition     = conditionsBlocks.Any();
                if (hasCondition)
                {
                    this.AddConditionsToRoute(rule, linedRoute, conditionsBlocks, Reports.Resources.ApprovalRuleCardReport.If, 1);
                }
                var beforeStagesLinesCount = linedRoute.Count;

                // Задания.
                var stagesBlocks = block.Where(b => rule.Stages.Any(n => n.Number == b.SourceStage));
                foreach (var stagesBlock in stagesBlocks)
                {
                    var stage = rule.Stages.First(s => s.Number == stagesBlock.SourceStage);
                    var level = hasCondition ? 2 : 1;
                    Functions.ApprovalStage.AddStageToRoute(stage.Stage, linedRoute, string.Empty, level);
                }

                // Нет заданий.
                if (hasCondition && beforeStagesLinesCount == linedRoute.Count)
                {
                    var level = hasCondition ? 2 : 1;
                    this.AddEmptyLine(linedRoute, level);
                }

                addedBlocks.Add(block);
            }
        }
        private IEnumerable <ISignatureSetting> GetSignatureSettings(IApprovalRuleBase rule)
        {
            var businessUnits   = rule.BusinessUnits.Select(b => b.BusinessUnit).ToList();
            var documentKinds   = rule.DocumentKinds.Select(d => d.DocumentKind).ToList();
            var ruleDepartments = rule.Departments.Select(d => d.Department).ToList();
            var categories      = rule.DocumentGroups.Select(d => d.DocumentGroup).ToList();

            var defaultFilteredSignSettings = Functions.SignatureSetting.GetSignatureSettings(businessUnits, documentKinds)
                                              .Where(s => !s.Categories.Any() || !rule.DocumentGroups.Any() || s.Categories.Any(k => categories.Contains(k.Category)))
                                              .Where(s => s.DocumentFlow == rule.DocumentFlow || s.DocumentFlow == Docflow.SignatureSetting.DocumentFlow.All);

            var signatureSettings = defaultFilteredSignSettings.ToList();

            foreach (var setting in defaultFilteredSignSettings)
            {
                // Дофильтровать по видам документов согласно документопотоку, кейс - баг 80143.
                if (!rule.DocumentKinds.Any() &&
                    setting.DocumentFlow == Docflow.SignatureSetting.DocumentFlow.All &&
                    setting.DocumentKinds.Any())
                {
                    var documentFlows = setting.DocumentKinds.Select(x => x.DocumentKind.DocumentFlow).Distinct();
                    if (!documentFlows.Contains(rule.DocumentFlow))
                    {
                        signatureSettings.Remove(setting);
                    }
                }

                // Дофильтровать по подразделениям отдельно, так как подразделений может быть огромное число и Contains() упадет.
                if (!ruleDepartments.Any() || !setting.Departments.Any())
                {
                    continue;
                }

                var flag = false;
                var signatureSettingDepartments = setting.Departments.Select(sd => sd.Department).ToList();
                foreach (var signatureDepartment in signatureSettingDepartments)
                {
                    if (ruleDepartments.Any(d => Equals(d, signatureDepartment)))
                    {
                        flag = true;
                        break;
                    }
                }

                if (!flag)
                {
                    signatureSettings.Remove(setting);
                }
            }

            return(signatureSettings);
        }
示例#3
0
        public static void CreateAutoTransitions(IApprovalRuleBase rule)
        {
            rule.Transitions.Clear();

            foreach (var stage in rule.Stages.OrderBy(x => x.Number))
            {
                var nextStage = rule.Stages.Where(s => s.Number > stage.Number).Min(s => s.Number);
                if (nextStage != null)
                {
                    var transition = rule.Transitions.AddNew();
                    transition.SourceStage = stage.Number;
                    transition.TargetStage = nextStage;
                }
            }
        }
        private void AddConditionToRoute(IApprovalRuleBase rule,
                                         List <Structures.ApprovalRuleCardReport.ConditionTableLine> linedRoute,
                                         IConditionBase condition,
                                         bool direction,
                                         string prefix,
                                         int level)
        {
            var conditionInfo  = new Structures.ApprovalRuleCardReport.ConditionTableLine();
            var conditionValue = direction ? Sungero.Docflow.Reports.Resources.ApprovalRuleCardReport.True : Sungero.Docflow.Reports.Resources.ApprovalRuleCardReport.False;
            var conditionName  = string.Format("{0}{1}", Functions.ConditionBase.GetConditionName(condition), conditionValue);

            var header = string.Format("{0} {1}", prefix, conditionName);

            conditionInfo.Header      = BreakLineAndAddPadding(header, Constants.ApprovalRuleCardReport.ConditionCellWidth, level);
            conditionInfo.Level       = level;
            conditionInfo.IsCondition = true;

            linedRoute.Add(conditionInfo);
        }
        private void AddConditionsToRoute(IApprovalRuleBase rule,
                                          List <Structures.ApprovalRuleCardReport.ConditionTableLine> linedRoute,
                                          List <Structures.ApprovalRuleCardReport.Transition> conditions,
                                          string prefix,
                                          int level)
        {
            var conditionInfo   = new Structures.ApprovalRuleCardReport.ConditionTableLine();
            var resources       = Sungero.Docflow.Reports.Resources.ApprovalRuleCardReport;
            var conditionsNames = conditions.Select(b => string.Format("{0}{1}",
                                                                       Functions.ConditionBase.GetConditionName(rule.Conditions.First(s => s.Number == b.SourceStage).Condition),
                                                                       b.ConditionValue == true ? resources.True : resources.False));
            var conditionsNamesLabel = string.Join(string.Format("{0}{1}", System.Environment.NewLine, Reports.Resources.ApprovalRuleCardReport.And), conditionsNames);
            var header = string.Format("{0} {1}", prefix, conditionsNamesLabel);

            conditionInfo.Header      = BreakLineAndAddPadding(header, Constants.ApprovalRuleCardReport.ConditionCellWidth, level);
            conditionInfo.Level       = level;
            conditionInfo.IsCondition = true;

            linedRoute.Add(conditionInfo);
        }
        private List <List <Structures.ApprovalRuleCardReport.Transition> > GetLinedSteps(IApprovalRuleBase rule,
                                                                                          List <Structures.ApprovalRuleCardReport.ConditionTableLine> linedRoute,
                                                                                          ref int?lastNumber)
        {
            var steps      = new List <List <Structures.ApprovalRuleCardReport.Transition> >();
            var nextNumber = lastNumber;
            var variants   = Functions.ApprovalRuleBase.GetAllStagesVariants(rule);

            foreach (var variant in variants.AllSteps.OrderBy(v => string.Join(string.Empty, v)))
            {
                var variantSteps = new List <Structures.ApprovalRuleCardReport.Transition>();
                foreach (var stage in variant)
                {
                    if (stage == lastNumber || variantSteps.Any())
                    {
                        // Завершить ветку, когда дошли до внешнего конца ветвления.
                        if (variants.AllSteps.All(s => s.Contains(stage)))
                        {
                            steps.Add(variantSteps);
                            variantSteps = new List <Structures.ApprovalRuleCardReport.Transition>();
                            nextNumber   = stage;
                            break;
                        }

                        if (rule.Stages.Any(s => s.Number == stage))
                        {
                            var ruleTransition = rule.Transitions.FirstOrDefault(t => t.SourceStage == stage);
                            var condition      = ruleTransition == null ? null : ruleTransition.ConditionValue;
                            var transition     = Structures.ApprovalRuleCardReport.Transition.Create(stage, condition);
                            variantSteps.Add(transition);
                            if (ruleTransition == null)
                            {
                                steps.Add(variantSteps);
                                variantSteps = new List <Structures.ApprovalRuleCardReport.Transition>();
                                nextNumber   = null;
                                continue;
                            }
                        }
                        else if (rule.Conditions.Any(s => s.Number == stage))
                        {
                            var ruleTransition    = rule.Transitions.FirstOrDefault(t => t.SourceStage == stage && variant.Contains(t.TargetStage.Value));
                            var cuttentStageIndex = variant.IndexOf(stage);
                            if (cuttentStageIndex < variant.Count - 1)
                            {
                                var nextStage = variant[cuttentStageIndex + 1];
                                ruleTransition = rule.Transitions.FirstOrDefault(t => t.SourceStage == stage && t.TargetStage.Value == nextStage);
                            }

                            bool?condition = null;
                            if (ruleTransition != null)
                            {
                                condition = ruleTransition.ConditionValue;
                            }
                            else
                            {
                                var alternativeRuleTransition = rule.Transitions.FirstOrDefault(t => t.SourceStage == stage);
                                if (alternativeRuleTransition != null)
                                {
                                    condition = alternativeRuleTransition.ConditionValue == false;
                                }
                            }

                            var transition = Structures.ApprovalRuleCardReport.Transition.Create(stage, condition);
                            variantSteps.Add(transition);
                            if (ruleTransition == null)
                            {
                                steps.Add(variantSteps);
                                variantSteps = new List <Structures.ApprovalRuleCardReport.Transition>();
                                nextNumber   = null;
                                continue;
                            }
                        }
                    }
                }
            }

            lastNumber = nextNumber;
            return(steps);
        }
        private List <Structures.ApprovalRuleCardReport.ConditionTableLine> GetRouteDescription(IApprovalRuleBase rule, int?lastNumber)
        {
            var linedRoute = new List <Structures.ApprovalRuleCardReport.ConditionTableLine>();

            while (true)
            {
                // Последний этап блок (не условие).
                if (rule.Stages.Any(s => s.Number == lastNumber))
                {
                    var stage = rule.Stages.First(s => s.Number == lastNumber).Stage;
                    Functions.ApprovalStage.AddStageToRoute(stage, linedRoute, string.Empty, 0);
                    var lastTransition = rule.Transitions.FirstOrDefault(s => s.SourceStage == lastNumber);
                    if (lastTransition != null)
                    {
                        lastNumber = lastTransition.TargetStage.Value;
                    }
                    else
                    {
                        break;
                    }
                }
                else if (rule.Conditions.Any(s => s.Number == lastNumber))
                {
                    var resources = Reports.Resources.ApprovalRuleCardReport;
                    var condition = rule.Conditions.First(s => s.Number == lastNumber).Condition;
                    this.AddConditionToRoute(rule, linedRoute, condition, true, resources.If, 0);

                    // Переход по условию по ветке true.
                    var nextNumber             = lastNumber;
                    var trueResultTransition   = rule.Transitions.FirstOrDefault(t => t.SourceStage == lastNumber && t.ConditionValue == true);
                    var beforeStagesLinesCount = linedRoute.Count;
                    if (trueResultTransition != null)
                    {
                        nextNumber = trueResultTransition.TargetStage.Value;
                        var steps = this.GetLinedSteps(rule, linedRoute, ref nextNumber);
                        this.AddStepsToRoute(rule, linedRoute, steps);
                    }
                    if (linedRoute.Count == beforeStagesLinesCount)
                    {
                        this.AddEmptyLine(linedRoute, 1);
                    }

                    // Переход по условию по ветке false.
                    this.AddConditionToRoute(rule, linedRoute, condition, false, resources.ElseIf, 0);
                    var falseResultTransition = rule.Transitions.FirstOrDefault(t => t.SourceStage == lastNumber && t.ConditionValue == false);
                    if (falseResultTransition != null)
                    {
                        nextNumber = falseResultTransition.TargetStage.Value;
                        var steps = this.GetLinedSteps(rule, linedRoute, ref nextNumber);
                        beforeStagesLinesCount = linedRoute.Count;
                        this.AddStepsToRoute(rule, linedRoute, steps);
                        if (linedRoute.Count == beforeStagesLinesCount)
                        {
                            this.AddEmptyLine(linedRoute, 1);
                        }
                    }
                    else
                    {
                        this.AddEmptyLine(linedRoute, 1);
                    }

                    if (lastNumber == nextNumber)
                    {
                        break;
                    }

                    lastNumber = nextNumber;
                    this.AddConditionToRoute(rule, linedRoute, condition, false, resources.EndIf, 0);
                }
                else
                {
                    break;
                }
            }
            return(linedRoute);
        }
        public List <Structures.ApprovalRuleCardReport.ConditionTableLine> GetConditionTableData(IApprovalRuleBase rule, string reportSessionId)
        {
            var tableData  = new List <Structures.ApprovalRuleCardReport.ConditionTableLine>();
            var firstStage = rule.Transitions.Select(x => x.SourceStage).FirstOrDefault(s => !rule.Transitions.Any(t => t.TargetStage.Equals(s)));

            if (rule.Stages.Count == 1 && !rule.Conditions.Any() && !firstStage.HasValue)
            {
                firstStage = rule.Stages.Single().Number;
            }

            tableData = this.GetRouteDescription(rule, firstStage);
            var id = 0;

            tableData[0].ReportSessionId = reportSessionId;
            tableData[0].Id = id;
            for (var i = 1; i < tableData.Count; i++)
            {
                tableData[i].ReportSessionId = reportSessionId;
                if (!Equals(tableData[i - 1].Header, tableData[i].Header))
                {
                    id++;
                }
                tableData[i].Id = id;
            }
            return(tableData);
        }
        /// <summary>
        /// Получить данные для отображения прав подписи.
        /// </summary>
        /// <param name="rule">Правило согласования.</param>
        /// <param name="reportSessionId">ID отчета.</param>
        /// <returns>Список структур с данными о правах подписи.</returns>
        private List <Structures.ApprovalRuleCardReport.SignatureSettingsTableLine> GetSignatureSettingsTableData(IApprovalRuleBase rule, string reportSessionId)
        {
            var tableData         = new List <Structures.ApprovalRuleCardReport.SignatureSettingsTableLine>();
            var signatureSettings = this.GetSignatureSettings(rule)
                                    .OrderByDescending(x => x.Priority).ToList();

            foreach (var signSetting in signatureSettings)
            {
                var displayValue       = this.GetDisplayValuePresentation(signSetting);
                var id                 = signSetting.Id;
                var hyperlink          = Hyperlinks.Get(signSetting);
                var orderNumber        = signatureSettings.IndexOf(signSetting);
                var unitsAndDeps       = this.GetBusinessUnitsAndDepartmentsPresentation(signSetting);
                var kindsAndCategories = this.GetDocumentKindsAndCategoriesPresentation(signSetting);
                var priority           = signSetting.Priority ?? 0;

                // Лимит.
                var limits = string.Empty;
                if ((signSetting.DocumentFlow == SignatureSetting.DocumentFlow.Contracts ||
                     signSetting.DocumentFlow == SignatureSetting.DocumentFlow.All) &&
                    signSetting.Limit == SignatureSetting.Limit.Amount &&
                    signSetting.Amount.HasValue && signSetting.Currency != null)
                {
                    limits = string.Format("{0} {1}",
                                           signSetting.Amount.Value.ToString("N2"),
                                           signSetting.Currency.AlphaCode);
                }

                // Срок.
                var validTill = string.Empty;
                if (signSetting.ValidTill.HasValue)
                {
                    validTill = signSetting.ValidTill.Value.ToShortDateString();
                }

                // Примечание.
                var note = signSetting.Note;

                tableData.Add(this.CreateSignatureSettingsTableLine(displayValue, id, hyperlink, orderNumber, unitsAndDeps, kindsAndCategories, priority, limits, validTill, note));
            }

            return(tableData);
        }