Отвечай на вопросы, используя следующий контекст:
/// <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
                    ? "Чувствительные изменения при перерасчете обнаружены"
                    : "Чувствительные изменения при перерасчете не обнаружены";
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);
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 (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);
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;
        }
    }
}
// Если продукт существует, то проверим, сколько у него дочерних услоий. Если нет ни одного - удаляем
            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;
/// <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();
                    }
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;
            }
        }
logger?.Information($"{sensitiveChangeMessage}, статус URM до перерасчета: {externalBasketUrmAprovalStatus}");
            }

            if (!isSensitiveDataChanged && (
                externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.Accepted || 
                externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.AcceptedWithLimits ||
                externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.RequiredExtraInfo))
            { 
                SetExternalBasketUrmAprovalStatus(deal, externalBasketUrmAprovalStatus);
                return;
            }

            try
            {
                var sw = Stopwatch.StartNew();

                var requestGuid = Guid.NewGuid().ToString();
                if (deal.AutoDeal.IsSasCoefficientOutdate != false)
                {
                    var firstCheckResult = await checkKaskoUpProjectServiceAdapter.FirstCheckBasketAsync(basket, deal, priceMax, requestGuid);

                    AutoCheckResultHelper.CreateKaskoRtdmAutoCheckResult(deal, firstCheckResult);
                }

                var secondCheckResult = await checkKaskoUpProjectServiceAdapter.SecondCheckBasketAsync(basket, deal, requestGuid);
                var decision = secondCheckResult.FinDecision?.ToLower();

                sw.Stop();

                logger?.ForContext("BasketNumber", basket.Number)
                    .Information("Блок проверки Check Kasko Project SAS: {TotalTime} ms", sw.ElapsedMilliseconds);

                AutoCheckResultHelper.CreateKaskoRtdmPassportCheckAutoCheckResult(deal, secondCheckResult);

                var comment = $"Проверка через SAS. {decision}";

                logger?.ForContext("BasketNumber", basket.Number)
                    .Information(comment, sw.ElapsedMilliseconds);

                if (secondCheckResult.Inspection || (decision is KaskoSasCheckProcessConstants.KaskoSasCheckNoDecision && deal.GetAuto().HasMileage == true))
                {
                    deal.EntityContext[PsoEntityValuesConstants.IsInspectionForPartnerBySasDecision] = true;
                }

                UpdateSasApprovalInDeal(deal, SASApprovalStatusCodeHelper.GetSASStatusCode(decision), secondCheckResult.SasCoefficient);
                string exitBranch = string.Empty;               

                switch (decision)
                {
                    case KaskoSasCheckProcessConstants.KaskoSasCheckAccept:
                        if (isSensitiveDataChanged && (
                            externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.Accepted || 
                            externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.AcceptedWithLimits ||
                            externalBasketUrmAprovalStatus == UrmApprovalStatusCodes.RequiredExtraInfo))
                        {
                            SetExternalBasketUrmAprovalStatus(deal, externalBasketUrmAprovalStatus);
                        }
                        else
                        {
                            UrmHelper.SetUrmApprovalNotRequired(deal);
                        }
//Проставляем условия из верхней группы (при этом удалим проставленные из dealConditionsStructIds)
                FillSingleDealConditionByConditionsStructIdsFromTopGroup(deal, conditionsFilter, toggledCondition, dealConditionsStructIdsFromTopGroup, dealConditionsStructIds);

                var needRemoveDeal = FillSingleDealConditions(deal, toggledCondition, conditionsFilter, dealConditionsStructIds);
                if (needRemoveDeal)
                {
                    dealsToDelete.Add(deal);
                }

                // Удаляем InsuranceObject со сделки, если нет для них InsuranceObjectCondition в сделке
                ClearDealFromUnsuitableInsuranceObjects(deal);
            }

            _currencyDeterminator.DetermineCurrenciesForDealsAndConditions(deals);

            //Отбрасываем сделки(офферы), которые не подходят из-за снятия условий в констр-ре
            RemoveUnsuitableDeals(deals, dealsToDelete);
        }

        private void FillSingleDealConditionByConditionsStructIdsFromTopGroup(Deal deal, KaskoConditionsFilter conditionsFilter, ToggledCondition toggledCondition, List<StructIdAndSum> dealConditionsStructIdsFromTopGroup, List<StructIdAndSum> dealConditionsStructIds)
        {
            foreach (var structIdAndSum in dealConditionsStructIdsFromTopGroup)
            {
                var productConfiguration = conditionsFilter.GetProductConfigurationByStructId(structIdAndSum.StructId);

                if (productConfiguration.IsMain())
                {
                    // найти все родительские условия для structId
                    List<ProductConfiguration> parentConfigurations = conditionsFilter.GetParentProductConfigurationsFor(structIdAndSum.StructId);
                    parentConfigurations.Add(productConfiguration);

                    FillConditionUp(deal, parentConfigurations, dealConditionsStructIds);
                    dealConditionsStructIds.Remove(structIdAndSum);
                }
                else
                {
                    AddProductConfigurationToDeal(productConfiguration, deal, toggledCondition);
                    dealConditionsStructIds.Remove(structIdAndSum);
                }
            }
        }

        private void RemoveUnsuitableDeals(List<Deal> deals, List<Deal> dealsToDelete)
        {
            foreach (var dealToDelete in dealsToDelete)
            {
                deals.Remove(dealToDelete);
            }
        }

        /// <summary>
        /// Получаем сделки, которые не содержат все выбранные условия из верхней группы
        /// </summary>
        /// <param name="deals">Исходный список сделок</param>
        /// <param name="dealConditionsStructIdsFromTopGroup">Условия из верхней группы</param>
        /// <returns>Сделки, которые не содержат все выбранные условия из верхней группы</returns>
        private List<Deal> GetUnsuitableDeals(List<Deal> deals, List<StructIdAndSum> dealConditionsStructIdsFromTopGroup, bool? useDrafts)
        {
            List<Deal> dealsToRemove = new List<Deal>();
            foreach (var deal in deals)
            {
                var dealOfferIds = deal.Proposals.Select(x => x.Offer_Id).Distinct().ToArray();
                var dealOffers = _queryOffer.GetOffers(dealOfferIds, deal.DateActual ?? DT.Now, useDrafts).ToList();
                var dealOfferStructs = dealOffers.SelectMany(o => o.OfferStructs);

                foreach (var structIdAndSum in dealConditionsStructIdsFromTopGroup)
                {
                    bool structIdAndSumInDeal = false;

                    foreach (var offerStruct in dealOfferStructs)
                    {
                        if (!_allProductConfigs.ContainsKey(offerStruct.Id))
                        {
                            break;
                        }

                        var productConfiguration = _allProductConfigs[offerStruct.Id];
                        var sum = _sumManager.GetSumForProductConfiguration(productConfiguration, deal: deal);
какой страйкт айди у риска дтп со вторым участником?