Отвечай на вопросы, используя следующий контекст:
/// <summary>
        /// Переход Не ЦС. CorrData.
        /// </summary>
        public const string ExitBranch_NotTargetedSegment_CorrData = "NotTargetedSegment_CorrData";

        /// <summary>
        /// Сделка.
        /// </summary>
        public const string InputArgument_Deal = nameof(Deal);

        /// <summary>
        /// Корзина.
        /// </summary>
        public const string InputArgument_Basket = nameof(Basket);

        /// <summary>
        /// Имеются чувствительные данные при перерасчете.
        /// </summary>
        public const string InputArgument_IsSensitiveDataChanged = "IsSensitiveDataChanged";

        /// <summary>
        /// Проверки urm до перерасчета.
        /// </summary>
        public const string InputArgument_ExternalBasketUrmAproval = "ExternalBasketUrmAproval";

        /// <summary>
        /// Ошибки от SAS.
        /// </summary>
        public const string OutpuArgument_Value = nameof(Value);

        /// <summary>
        /// Входной параметр - Cделка.
        /// </summary>
        public InputArgument<Deal> Deal { get; } = new InputArgument<Deal>(InputArgument_Deal);

        /// <summary>
        /// Входной параметр - Корзина.
        /// </summary>
        public InputArgument<Basket> Basket { get; } = new InputArgument<Basket>(InputArgument_Basket);

        /// <summary>
        /// Входной параметр - Наименование процесса.
        /// </summary>
        [Obsolete("Не используется с 09.09.21")]
        public InputArgument<string> ProcessName { get; } = new InputArgument<string>("ProcessName");

        /// <summary>
        /// Выходоной параметр - сообщение об ошибке.
        /// </summary>
        /// <output/>
        public OutputArgument<string> Value { get; } = new OutputArgument<string>(OutpuArgument_Value);

        /// <summary>
        /// Входной параметр - Чувствительные изменения при перерасчете.
        /// </summary>
        public InputArgument<bool> IsSensitiveDataChanged { get; } = new InputArgument<bool>(InputArgument_IsSensitiveDataChanged);

        /// <summary>
        /// Входной параметр - Проверки URM корзины до перерасчета.
        /// </summary>
        public InputArgument<URMApproval> ExternalBasketUrmAproval { get; } = new InputArgument<URMApproval>(InputArgument_ExternalBasketUrmAproval);

        /// <inheritdoc />
        public void Execute(IProcessContext processContext)
        {
            ExecuteAsync(processContext).GetAwaiter().GetResult();
        }

        /// <inheritdoc />
        public async Task ExecuteAsync(IProcessContext processContext)
        {
            var logger = processContext.ServiceProvider.GetService<ILogger>()?.ForContext<KaskoSasCheckProcess>();

            var deal = Deal.Get(processContext);
            var basket = Basket.Get(processContext);
            IsSensitiveDataChanged.TryGet(processContext, out var isSensitiveDataChanged);
            ExternalBasketUrmAproval.TryGet(processContext, out var externalBasketUrmAproval);

            var checkKaskoUpProjectServiceAdapter = processContext.ServiceProvider.GetService<ICheckKaskoUpProjectServiceAdapter<Basket, Deal>>();
            var autoCostCalculator = processContext.ServiceProvider.GetService<IAutoCostCalculator>();
            var validationResultsAggregator = processContext.ServiceProvider.GetRequiredService<IValidationResultsAggregator>();
            var priceMax = await SasRequestResultHelper.GetMaxPriceAsync(autoCostCalculator, deal);

            var integrationLoginName = processContext.GetCustomVariable(Link2Constants.IntegrationLoginKey) as string;

            string externalBasketUrmAprovalStatus = externalBasketUrmAproval?.URMApprovalStatusCode;

            if (externalBasketUrmAproval != null)
            {
                string sensitiveChangeMessage = isSensitiveDataChanged
                    ? "Чувствительные изменения при перерасчете обнаружены"
                    : "Чувствительные изменения при перерасчете не обнаружены";
if (deleteOther)
            {
                // Удяляем все опции, кроме тех, которые добавили
                block.DealOptions = block.DealOptions.Where(x => optionsConfigs.Select(c => c.ProductConfiguration.StructId).Contains(x.StructId)).ToList();
            }
        }

        /// <summary>
        /// Добавляет список франшиз в блок. Если передан флаг deleteOthers, удаляет другие франшизы в блоке.
        /// </summary>
        /// <param name="block">Блок условий.</param>
        /// <param name="francisesConfigs">Настройки для фрашиз.</param>
        /// <param name="deleteOther">Флаг удаления других франшиз в блоке.</param>
        /// <param name="toggledCondition">Переключаемое условие.</param>
        private void AddFranchiseToBlocks(ConditionBlock block, List<ProductConfigurationAndSum> francisesConfigs, bool deleteOther, ToggledCondition toggledCondition = null)
        {
            MakeEmptyCollectionIfNull(block.DealFranchises);

            foreach (var franchiseConfig in francisesConfigs)
            {
                if (block.DealFranchises.FirstOrDefault(x => x.StructId == franchiseConfig.ProductConfiguration.StructId) != null)
                {
                    return;
                }

                var setSums = _sumManager.GetSumsForProductConfiguration(franchiseConfig.ProductConfiguration, out var defaultSetSum);

                decimal? sum =
                    IsSumContains(franchiseConfig.Sum, setSums, defaultSetSum) && franchiseConfig.Sum > 0
                        ? franchiseConfig.Sum
                        : _sumManager.GetSumForProductConfiguration(franchiseConfig.ProductConfiguration, toggledCondition);

                var franchise = new DealFranchise
                {
                    StructId = franchiseConfig.ProductConfiguration.StructId,
                    ProductFranchise_Id = franchiseConfig.ProductConfiguration.ProductFranchise_Id,
                    ProductFranchise = franchiseConfig.ProductConfiguration.ProductFranchise,
                    Sum = sum
                };

                franchise.ProductFranchise.SetSums.ForEach(s => s.SetReadonlyState(false));
                franchise.ProductFranchise.DefaultSetSum?.SetReadonlyState(false);

                block.DealFranchises.Add(franchise);
            }

            if (deleteOther)
            {
                // Удяляем все франшизы, кроме тех, которые добавили
                block.DealFranchises = block.DealFranchises.Where(x => francisesConfigs.Select(c => c.ProductConfiguration.StructId).Contains(x.StructId)).ToList();
            }
        }

        /// <summary>
        /// Добавляет список CompensationOptions в блок. Если передан флаг deleteOthers, удаляет другие CompensationOptions в блоке.
        /// </summary>
        /// <param name="block">Блок условий.</param>
        /// <param name="compensationOptionsConfigs">Настройки для CompensationOptions.</param>
        /// <param name="deleteOther">Флаг удаления других CompensationOptions в блоке.</param>
        /// <param name="toggledCondition">Переключаемое условие.</param>
        private void AddCompensationOptionsToBlocks(ConditionBlock block, List<ProductConfigurationAndSum> compensationOptionsConfigs, bool deleteOther, ToggledCondition toggledCondition = null)
        {
            MakeEmptyCollectionIfNull(block.DealCompensationOptions);

            foreach (var compensationOptionConfig in compensationOptionsConfigs)
            {
                if (block.DealCompensationOptions.FirstOrDefault(x => x.StructId == compensationOptionConfig.ProductConfiguration.StructId) != null)
                {
                    return;
                }

                decimal? sum = _sumManager.GetSumForProductConfiguration(compensationOptionConfig.ProductConfiguration, toggledCondition);
if (selectValue.HasValue)
                {
                    option.SelectValue = selectValue;
                }
                else
                {
                    option.Sum = sum;
                }

                option.ProductOption.SetSums.ForEach(s => s.SetReadonlyState(false));
                option.ProductOption.DefaultSetSum?.SetReadonlyState(false);

                block.DealOptions.Add(option);

                // Если это условие по которому чекнули, то его проставить, а остальные в блоке снять
                //if (startStructId != null && startStructId.Value == productConfiguration.StructId)
                //{
                //    block.DealCompensationOptions.Clear();
                //    block.DealFranchises.Clear();
                //}
            }

            if (deleteOther)
            {
                // Удяляем все опции, кроме тех, которые добавили
                block.DealOptions = block.DealOptions.Where(x => optionsConfigs.Select(c => c.ProductConfiguration.StructId).Contains(x.StructId)).ToList();
            }
        }

        /// <summary>
        /// Добавляет список франшиз в блок. Если передан флаг deleteOthers, удаляет другие франшизы в блоке
        /// </summary>
        /// <param name="block">Блок условий</param>
        /// <param name="francisesConfigs">Настройки для фрашиз</param>
        /// <param name="deleteOther">Флаг удаления других франшиз в блоке</param>
        /// <param name="toggledCondition">Переключаемое условие</param>
        private void AddFranchiseToBlocks(ConditionBlock block, List<ProductConfigurationAndSum> francisesConfigs, bool deleteOther, ToggledCondition toggledCondition = null)
        {
            MakeEmptyCollectionIfNull(block.DealFranchises);

            foreach (var franchiseConfig in francisesConfigs)
            {
                if (block.DealFranchises.FirstOrDefault(x => x.StructId == franchiseConfig.ProductConfiguration.StructId) != null)
                {
                    return;
                }

                var setSums = _sumManager.GetSumsForProductConfiguration(franchiseConfig.ProductConfiguration, out var defaultSetSum);

                decimal? sum =
                    IsSumContains(franchiseConfig.Sum, setSums, defaultSetSum) && franchiseConfig.Sum > 0
                        ? franchiseConfig.Sum
                        : _sumManager.GetSumForProductConfiguration(franchiseConfig.ProductConfiguration, toggledCondition);

                var franchise = new DealFranchise
                {
                    StructId = franchiseConfig.ProductConfiguration.StructId,
                    ProductFranchise_Id = franchiseConfig.ProductConfiguration.ProductFranchise_Id,
                    ProductFranchise = franchiseConfig.ProductConfiguration.ProductFranchise,
                    Sum = sum
                };

                franchise.ProductFranchise.SetSums.ForEach(s => s.SetReadonlyState(false));
                franchise.ProductFranchise.DefaultSetSum?.SetReadonlyState(false);

                block.DealFranchises.Add(franchise);

                // Если это условие по которому чекнули, то его проставить, а остальные в блоке снять
                //if (startStructId != null && startStructId.Value == productConfiguration.StructId)
                //{
                //    block.DealCompensationOptions.Clear();
                //    block.DealFranchises.Clear();
                //}
            }

            if (deleteOther)
            {
                // Удяляем все франшизы, кроме тех, которые добавили
                block.DealFranchises = block.DealFranchises.Where(x => francisesConfigs.Select(c => c.ProductConfiguration.StructId).Contains(x.StructId)).ToList();
            }
        }
// Если продукт существует, то проверим, сколько у него дочерних услоий. Если нет ни одного - удаляем
            if (product != null)
            {
                var dealProduct = deal.StructId;
                var hasMoreThanOneChild = _allProductConfigs.Values.Where(x => x.ParentStructId == deal.StructId).Count() > 1;
                isRequired = currentNode.IsRequired();
                bool isMainCondition = currentNode.IsMain();

                if (dealProduct != null && ((!hasMoreThanOneChild && isMainCondition) || isRequired))
                {
                    return true;
                }
            }

            return false;
        }

        // Заполняет условия в поддереве, начиная с условия toogledStructId и вниз
        private void FillDealConditionsDown(Deal deal, ToggledCondition toggledCondition, KaskoConditionsFilter conditionsFilter, List<int> dealConditionsStructIds, out List<int> pastStructIds)
        {
            pastStructIds = new List<int>();

            if (toggledCondition.StructIds.Count == 0)
            {
                return;
            }

            if (toggledCondition.IsChecked || toggledCondition.IsDropDown)
            {
                // Получить дочерние условия + изменяемое условие как список (изменяемое условие делаю первым в списке для дальнейше обработки)
                var childConfigurations = conditionsFilter.GetRequiredChildProductConfigurationsFor(toggledCondition.StructIds, dealConditionsStructIds);
                var toogledProductConfigurations = conditionsFilter.GetProductConfigurationByStructIds(toggledCondition.StructIds);
                childConfigurations.InsertRange(0, toogledProductConfigurations);

                // проставить все дочерние условия
                foreach (var childConfiguration in childConfigurations)
                {
                    AddProductConfigurationToDeal(childConfiguration, deal, toggledCondition, false);
                    pastStructIds.Add(childConfiguration.StructId.Value);
                }
            }
            else
            {
                // var deletedStructIds = _dealManager.FillAllDealConditionsWhenUncheck(deal, toggledCondition.StructIds[0], _allProductConfigs.Values.ToList());
                //dealConditionsStructIds.RemoveAll(x => deletedStructIds.Contains(x));
                //pastStructIds = deletedStructIds;
                var childsProductConfigurationsToRemove = conditionsFilter.GetChildProductConfigurationsFor(toggledCondition.StructIds, dealConditionsStructIds);
                var toogledProductConfigurations = conditionsFilter.GetProductConfigurationByStructIds(toggledCondition.StructIds);
                if (toogledProductConfigurations.Count > 0)
                {
                    childsProductConfigurationsToRemove.AddRange(toogledProductConfigurations);
                }

                var structIdsToRemove = childsProductConfigurationsToRemove.Select(x => x.StructId.Value);

                dealConditionsStructIds.RemoveAll(x => structIdsToRemove.Contains(x));

                pastStructIds.AddRange(structIdsToRemove);
            }
        }

        /// <summary>
        /// Очищаем сделку от условий, у которых не заполнены дочерние элементы
        /// </summary>
        /// <param name="deal">Сделка</param>
        private void ClearDealFromIncorrectConditions(Deal deal)
        {
            var coverages = deal.DealConditionGroups.SelectMany(x => x.InsuranceObjectConditions).SelectMany(x => x.DealCoverages).ToList();
            foreach (var coverage in coverages)
            {
                if (coverage.DealRisks == null || coverage.DealRisks.Count == 0)
                {
                    var conditionBlock = coverage.ConditionBlock;
if (offerStruct.StructId == structIdAndSum.StructId && sum == structIdAndSum.Sum)
                        {
                            structIdAndSumInDeal = true;
                            break;
                        }
                    }

                    // Если не нашли в сделке хоть одно условие  суммой, то сделку удалять
                    if (!structIdAndSumInDeal)
                    {
                        dealsToRemove.Add(deal);
                        break;
                    }
                }
            }

            //var result = deals.Where(x => !dealConditionsStructIdsFromTopGroup.All(c => x.Proposals.Select(p => p.Offer).SelectMany(o => o.OfferStructs).Select(os => os.StructId).Contains(c.StructId))).ToList();
            return dealsToRemove;
        }

        // реализация по заполнения обязательными и дефолтными условиями
        private void FillSingleDealConditions(
            Deal deal,
            KaskoConditionsFilter conditionsFilter,
            List<StructIdAndSum> dealConditionsStructIdsAndSums,
            List<int> structIdsToIgnore,
            ToggledCondition toggledCondition,
            bool? loadDefaultConditions = null)
        {
            List<int> dealConditionsStructIds = dealConditionsStructIdsAndSums.Select(x => x.StructId).ToList();
            bool loadDefaultConditionsFlag = loadDefaultConditions ?? toggledCondition == null;

            MakeEmptyConditionBlockIfNull(deal);
            AddOCFConditionsToBlock(deal.StructId.Value, deal.ConditionBlock, conditionsFilter, dealConditionsStructIdsAndSums, structIdsToIgnore, loadDefaultConditionsFlag);

            //проставялем периоды страхования
            var insurancePeriodTemplates = _allProductConfigs.Select(x => x.Value).Where(x => x.ParentStructId == deal.StructId).Where(x => x.InsurancePeriodTemplate != null);
            var dealPeriod = deal.ConditionBlock.DealPeriods?.FirstOrDefault();

            if (dealPeriod == null)
            {
                dealPeriod = new Period();
                deal.ConditionBlock.DealPeriods.Add(dealPeriod);
            }

            dealPeriod.InsurancePeriodTemplate = dealPeriod.InsurancePeriodTemplate ?? insurancePeriodTemplates.FirstOrDefault()?.InsurancePeriodTemplate;

            // Получить все обязательные и по умолчанию Группы           
            var conditionGroups = conditionsFilter.GetConditionGroupsConfigurations(loadDefaultConditionsFlag, deal.StructId, dealConditionsStructIds, toggledCondition);
            var conditionGroupsAndSums = GetProductConfigurationsAndSums(conditionGroups, dealConditionsStructIdsAndSums);

            // Добавить группы в сделку
            foreach (var conditionGroup in conditionGroupsAndSums)
            {
                if (structIdsToIgnore.Contains(conditionGroup.ProductConfiguration.StructId.Value))
                {
                    continue;
                }

                AddConditionGroupToDeal(deal, conditionGroup);
            }

            foreach (var dealConditionGroup in deal.DealConditionGroups)
            {
                MakeEmptyConditionBlockIfNull(dealConditionGroup);
                AddOCFConditionsToBlock(dealConditionGroup.StructId.Value, dealConditionGroup.ConditionBlock, conditionsFilter, dealConditionsStructIdsAndSums, structIdsToIgnore, loadDefaultConditionsFlag);
                RemoveEmptyConditionBlock(dealConditionGroup, dealConditionGroup.ConditionBlock);

                var ioTypeConditions =
                    conditionsFilter.GetInsuranceObjectTypeConfiguarations(
                        dealConditionGroup.StructId.Value,
                        loadDefaultConditionsFlag,
                        dealConditionsStructIds,
                        toggledCondition);

                foreach (var ioTypeCondition in ioTypeConditions)
                {
                    if (structIdsToIgnore.Contains(ioTypeCondition.StructId.Value))
                    {
                        continue;
                    }
/// <summary>
        /// Добавляет список CompensationOptions в блок. Если передан флаг deleteOthers, удаляет другие CompensationOptions в блоке
        /// </summary>
        /// <param name="block">Блок условий</param>
        /// <param name="compensationOptionsConfigs">Настройки для CompensationOptions</param>
        /// <param name="deleteOther">Флаг удаления других CompensationOptions в блоке</param>
        /// <param name="toggledCondition">Переключаемое условие</param>
        private void AddCompensationOptionsToBlocks(ConditionBlock block, List<ProductConfigurationAndSum> compensationOptionsConfigs, bool deleteOther, ToggledCondition toggledCondition = null)
        {
            MakeEmptyCollectionIfNull(block.DealCompensationOptions);

            foreach (var compensationOptionConfig in compensationOptionsConfigs)
            {
                if (block.DealCompensationOptions.FirstOrDefault(x => x.StructId == compensationOptionConfig.ProductConfiguration.StructId) != null)
                {
                    return;
                }

                decimal? sum = _sumManager.GetSumForProductConfiguration(compensationOptionConfig.ProductConfiguration, toggledCondition);

                var compensationOption = new DealCompensationOptions
                {
                    StructId = compensationOptionConfig.ProductConfiguration.StructId,
                    ProductCompensationOption_Id = compensationOptionConfig.ProductConfiguration.ProductCompensationOption.Id,
                    ProductCompensationOption = compensationOptionConfig.ProductConfiguration.ProductCompensationOption,
                    Sum = sum
                };

                compensationOption.ProductCompensationOption.SetSums.ForEach(s => s.SetReadonlyState(false));
                compensationOption.ProductCompensationOption.DefaultSetSum?.SetReadonlyState(false);

                block.DealCompensationOptions.Add(compensationOption);

                // Если это условие по которому чекнули, то его проставить, а остальные в блоке снять
                //if (startStructId != null && startStructId.Value == productConfiguration.StructId)
                //{
                //    block.DealCompensationOptions.Clear();
                //    block.DealFranchises.Clear();
                //}
            }

            if (deleteOther)
            {
                // Удяляем все франшизы, кроме тех, которые добавили
                block.DealCompensationOptions = block.DealCompensationOptions.Where(x => compensationOptionsConfigs.Select(c => c.ProductConfiguration.StructId).Contains(x.StructId)).ToList();
            }
        }

        private bool IsSumContains(decimal? configurationSum, IEnumerable<SetSum> setSums, decimal? defaultSum = null)
        {
            return setSums != null
                   && (setSums.Any(ss => ss.SumTypeCode == SumTypeEnum.Manual.ToString())
                       || setSums.Any(ss => ss.SumMin == configurationSum)
                       || (!setSums.Any() && defaultSum != null));
        }

        private bool IsSelectValueContains(decimal? selectValue, ProductOption productOption)
        {
            return productOption.ProductOptionSelectValues.Any(sv => sv.Value == selectValue);
        }

        private void MakeEmptyCollectionIfNull<T>(ObservableList<T> collection)
        {
            if (collection == null)
            {
                collection = new ObservableList<T>();
            }
        }

        private void MakeEmptyConditionBlockIfNull(object condition)
        {
            string type = condition.GetType().Name;
            switch (type)
            {
                case nameof(Deal):
                    if (((Deal)condition).ConditionBlock == null)
                    {
                        ((Deal)condition).ConditionBlock = new ConditionBlock();
                    }
private void AddValidationError(IValidationResultsAggregator validationResultsAggregator)
        {
            validationResultsAggregator.AppendValidationErrors(new ValidationError()
            {
                ErrorMessage = "Код: 300019.Оформление невозможно",
                CriticalLevel = ValidationCriticalLevel.CantContProc
            });
        }

        /// <summary>
        /// Добавление УРМ в сделку для случая, когда объекта еще нет, и включена настройка.
        /// Установка статуса NotRequired, когда настройка выключена.
        /// </summary>
        /// <param name="deal">Сделка.</param>
        /// <param name="requestGuid">Идентификатор запроса.</param>
        /// <param name="context">Контекст процесса.</param>
        /// <param name="integrationLoginName">Имя пользователя для интеграции.</param>
        /// <param name="logger">Логгер для записи логов.</param>
        /// <param name="decision">Решение сас, принятое по сделке.</param>
        /// <param name="isSensitiveDataChanged">Чувствительные изменения при перерасчете.</param>
        /// <param name="externalBasketUrmAprovalStatus">Urm статус до перерасчета.</param>
        private void FixUrm(
            Deal deal, 
            string requestGuid, 
            IProcessContext context, 
            string integrationLoginName, 
            ILogger logger, 
            string decision, 
            bool isSensitiveDataChanged, 
            string externalBasketUrmAprovalStatus)
        {
            if (decision == KaskoSasCheckProcessConstants.KaskoSasCheckUrm && isSensitiveDataChanged && (externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.Accepted || externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.AcceptedWithLimits))
            {
                //Создаем новую заявку required
                UrmHelper.AddUrmApprovalToDeal(deal, UrmApprovalStatusCodes.Required, requestGuid);
                return;
            }

            if (decision == KaskoSasCheckProcessConstants.KaskoSasCheckUrm && isSensitiveDataChanged && externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.RequiredExtraInfo)
            {
                UrmHelper.AddOrUpdateUrmApprovalToDeal(deal, UrmApprovalStatusCodes.Required, requestGuid);
                return;
            }

            bool needCheckUrm = NeedCheckUrm(decision, deal, context, integrationLoginName, logger);

            if (needCheckUrm)
            {
                UrmHelper.AddOrUpdateUrmApprovalToDeal(deal, UrmApprovalStatusCodes.Required, requestGuid);
            }
            else
            {
                UrmHelper.SetUrmApprovalNotRequired(deal);
            }
        }

        private bool NeedCheckUrm(string decision, Deal deal, IProcessContext context, string integrationLoginName, ILogger logger)
        {
            bool canSkipUrm = UrmHelper.CanSkipUrm(deal);
            bool needCheckUrmSetting = GetNeedCheckUrmKASKOSetting(context, integrationLoginName, logger);
            bool isWithoutUrmIndicatorOrNoSegments = UrmHelper.UrmCheckForWithoutURMIndicatorOrNoSegments(deal);

            return decision == KaskoSasCheckProcessConstants.KaskoSasCheckNoDecision
                ? !canSkipUrm && needCheckUrmSetting && !isWithoutUrmIndicatorOrNoSegments
                : !canSkipUrm && needCheckUrmSetting;
        }

        private bool GetNeedCheckUrmKASKOSetting(IProcessContext context, string integrationLoginName, ILogger logger)
        {
            var settingsManager = context.ServiceProvider.GetRequiredService<IEntitySettingsManager>();

            var needCheckUrmKASKOSetting = settingsManager.GetSettingForDefaultOrPartnerConfiguration(
                EntitySettingCodes.NeedCheckUrmKASKOSetting,
                EntitySettingCodes.NeedCheckUrmKASKOSettingDefault,
                EntitySettingCodes.NeedCheckUrmKASKOSettingByIntegrationLogin,
                new IntegrationLogin { IntegrationLoginName = integrationLoginName },
                true,
                logger);
private void InitializeDiKaskoQuestionnaireFormStep(FormDataModel model)
        {
            model.Identifier = "DiKaskoQuestionnaireFormStep";
            model.Name = "Отрисовка формы – анкета.";
            model.Description = @"Отрисовка формы – анкета.";
            model.FormDataType = FormDataType.Form;
            model.FormName = "DiKaskoQuestionnaireStep";
            model.FormNameExpression = null;
            model.VersionManagementActions = new List<VersionManagementAction>();
            model.VersionManagementActions.Add(VersionManagementAction.ResetCurrentChange);
            model.VersionManagementActions.Add(VersionManagementAction.LoadTechnicalVersion);
            model.VersionManagementActions.Add(VersionManagementAction.LoadUserVersion);
            model.VersionManagementActions.Add(VersionManagementAction.LoadCallCenterVersion);
            model.NotSaveDraft = false;
            model.FormNestedEntities = new List<FormNestedEntity>();
            model.NextStep = _initializeAddressesForInsurant;
        }

        private void Initializeissue(InputModel model)
        {
            model.Identifier = "issue";
            model.Name = "Вызов действия «Отправить»";
            model.Description = @"Вызов действия «Отправить»";
            model.PermissionType = "actionIssue";
            model.ActionDefinition = new ActionDefinition();
            model.ActionDefinition.ModelSyncMode = iRIS.Framework.Entity.Metadata.Data.Enum.ModelSyncMode.FullModel;
            model.ValidationGroups = new List<string>();
            model.ValidationGroups.Add("DiKaskoQuestionnaireDelivery");
            model.ValidationGroups.Add("Address");
            model.ValidationGroups.Add("DIUnderwriterApprovalFromCallcenter");
            model.ValidationGroups.Add("DiKaskoQuestionnaire");
            model.CriticalLevels = new List<iRIS.Framework.Entity.Metadata.ValidationCriticalLevel>();
            model.Bookmark = string.Empty;
            model.SuppressProcessResuming = false;
            model.ParallelInput = null;
            model.NextStep = _saveDraftBasketBlockAfterBuy;
        }

        private void InitializeContinueExit(ExitPointModel model)
        {
            model.Identifier = "ContinueExit";
            model.Name = "Анкета заполнена";
            model.Description = @"Продолжить оформление";
            model.ReturnParameters = new List<ParameterModel>();
        }

        private void InitializedateStartMessageInfo(FormDataModel model)
        {
            model.Identifier = "dateStartMessageInfo";
            model.Name = "DateStartMessageInfo";
            model.Description = string.Empty;
            model.FormDataType = FormDataType.Message;
            model.MessageExpression = @"Дата начала срока действия расчета не валидна";
            model.NotificationType = iRIS.Framework.Common.Notifications.NotificationType.Error;
            model.Caption = "Дата начала срока действия расчета";
            model.NextStep = null;
        }

        private void InitializeSaveDraftBasketBlockAfterBuy(VersionPublisherModel model)
        {
            model.Identifier = "SaveDraftBasketBlockAfterBuy";
            model.Name = "Сохранение черновика корзины";
            model.Description = @"F1. Сохранение черновика корзины";
            model.VersionAction = VersionAction.SaveDraft;
            model.RelationType = RelationType.Draft;
            model.NextStep = _checkStartDateOfCalculate;
            model.ExceptionNextStep = null;
        }
    }
}
exitBranch = ExitBranch_TargetedSegment;
                        break;
                    case KaskoSasCheckProcessConstants.KaskoSasCheckUrm:
                        UrmApprovalStatusHelper.SetURMApprovalStatus(basket, false, comment); // возможно не нужен этот вызов, поресерчить
                        FixUrm(deal, requestGuid, processContext, integrationLoginName, logger, decision, isSensitiveDataChanged, externalBasketUrmAprovalStatus);
                        exitBranch = ExitBranch_NotTargetedSegment_CorrData;
                        break;
                    case KaskoSasCheckProcessConstants.KaskoSasCheckNoDecision:
                        UrmApprovalStatusHelper.SetURMApprovalStatus(basket, false, comment); // возможно не нужен этот вызов, поресерчить
                        FixUrm(deal, requestGuid, processContext, integrationLoginName, logger, decision, isSensitiveDataChanged, externalBasketUrmAprovalStatus);
                        exitBranch = ExitBranch_NotTargetedSegment_CorrData;
                        break;
                    case KaskoSasCheckProcessConstants.KaskoSasCheckReject:
                    default:
                        SetUrmStatus(deal, UrmApprovalStatusCodes.Rejected, requestGuid, decision);
                        AddValidationError(validationResultsAggregator);
                        exitBranch = ExitBranch_NotTargetedSegment_Reject;
                        break;
                }

                processContext.SetExitBranch(exitBranch);
                logger?.ForContext("BasketNumber", basket.Number).Information($"Переход на {exitBranch}", sw.ElapsedMilliseconds);

                var dataServiceInvoker = processContext.ServiceProvider.GetRequiredService<IDataServiceInvoker>();
                dataServiceInvoker.Publish(deal.AutoDeal, _aggregateName);
            }
            catch (Exception ex)
            {
                logger.Error(ex, $"Ошибка в работе блока {GetType().Name}");

                AddValidationError(validationResultsAggregator);

                processContext.SetExitBranch(ExitBranch_NotTargetedSegment_Reject);
                logger?.ForContext("BasketNumber", basket.Number)
                                .Information($"Переход на {ExitBranch_NotTargetedSegment_Reject}");
            }
        }

        private void SetExternalBasketUrmAprovalStatus(Deal deal, string externalBasketUrmAprovalStatus)
        {
            var lastApproval = deal.AutoDeal?.URMApproval?.LastOrDefault();
            if (lastApproval != null) 
            {
                lastApproval.URMApprovalStatusCode = externalBasketUrmAprovalStatus;
            } 
        }

        private void SetUrmStatus(Deal deal, string urmApprovalStatus, string requestGuid, string sasDecision)
        {
            var lastApproval = deal.AutoDeal.URMApproval.LastOrDefault();
            if (lastApproval != null)
            {
                lastApproval.URMApprovalComment = $"Проверка через SAS. {sasDecision}";
                lastApproval.URMApprovalStatusCode = urmApprovalStatus;
                lastApproval.ApprovalId = requestGuid;
            }
        }

        private void UpdateSasApprovalInDeal(Deal deal, string sasApprovalStatus, decimal? sasCoefficient)
        {
            if (!deal.AutoDeal.SASApproval.Any())
            {
                deal.AutoDeal.SASApproval.Add(new SASApproval { SASApprovalStatusCode = sasApprovalStatus, SasCoefficient = sasCoefficient });
            }
            else
            {
                var approval = deal.AutoDeal.SASApproval.Last();

                approval.SASApprovalStatusCode = sasApprovalStatus;
                approval.SasCoefficient = sasCoefficient;
            }
        }
private bool FillDealConditionsUp(
            DealConditionsDto dealConditions,
            Deal deal,
            Dictionary<int, ProductConfiguration> allProductConfigs,
            ToggledCondition toggledCondition,
            KaskoConditionsFilter conditionsFilter,
            List<StructIdAndSum> dealConditionsStructIdsAndSums)
        {
            if (toggledCondition.StructIds.Count == 0)
            {
                return false;
            }

            if (toggledCondition.IsChecked || toggledCondition.IsDropDown)
            {
                foreach (var structId in toggledCondition.StructIds)
                {
                    // найти все родительские условия для toggledCondition, чтобы проставить или снять их
                    var parentConfigurations = conditionsFilter.GetParentProductConfigurationsFor(structId);

                    // проставить все родительские условия
                    FillConditionUp(dealConditions, deal, parentConfigurations, dealConditionsStructIdsAndSums);
                }

                return false;
            }
            else
            {
                List<int> dealConditionsStructIds = dealConditionsStructIdsAndSums.Select(x => x.StructId).ToList();
                return toggledCondition.StructIds.All(structId => UncheckConditionUp(dealConditions, allProductConfigs, conditionsFilter, structId, dealConditionsStructIds));
            }
        }

        // Заполняет условия в поддереве, начиная с условия toogledStructId и вниз
        private void FillDealConditionsDown(
            DealConditionsDto dealConditions,
            Deal deal,
            ToggledCondition toggledCondition,
            KaskoConditionsFilter conditionsFilter,
            List<int> dealConditionsStructIds,
            out List<int> pastStructIds)
        {
            pastStructIds = new List<int>();

            if (toggledCondition.StructIds.Count == 0)
            {
                return;
            }

            if (toggledCondition.IsChecked || toggledCondition.IsDropDown)
            {
                // Получить дочерние условия + изменяемое условие как список (изменяемое условие делаю первым в списке для дальнейше обработки)
                var childConfigurations = conditionsFilter.GetRequiredChildProductConfigurationsFor(toggledCondition.StructIds, dealConditionsStructIds);
                var toogledProductConfigurations = conditionsFilter.GetProductConfigurationByStructIds(toggledCondition.StructIds);
                childConfigurations.InsertRange(0, toogledProductConfigurations);

                // проставить все дочерние условия
                foreach (var childConfiguration in childConfigurations)
                {
                    AddProductConfigurationToDeal(dealConditions, childConfiguration, deal, toggledCondition, false);
                    pastStructIds.Add(childConfiguration.StructId.Value);
                }
            }
            else
            {
                var childsProductConfigurationsToRemove = conditionsFilter.GetChildProductConfigurationsFor(toggledCondition.StructIds, dealConditionsStructIds);
                var toogledProductConfigurations = conditionsFilter.GetProductConfigurationByStructIds(toggledCondition.StructIds);
                if (toogledProductConfigurations.Count > 0)
                {
                    childsProductConfigurationsToRemove.AddRange(toogledProductConfigurations);
                }

                var structIdsToRemove = childsProductConfigurationsToRemove.Select(x => x.StructId.Value);

                dealConditionsStructIds.RemoveAll(x => structIdsToRemove.Contains(x));

                pastStructIds.AddRange(structIdsToRemove);
            }
        }
какой structId у риска дтп со вторым участником?