Отвечай на вопросы, используя следующий контекст:
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;
/// <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);
/// <summary>
        /// Корзина oss.
        /// </summary>
        /// <input/>
        public InputArgument<string> OssBasketUni { get; } = new InputArgument<string>(InputArgument_OssBasketUni);

        public void Execute(IProcessContext processContext)
        {
            ExecuteAsync(processContext).GetAwaiter().GetResult();
        }

        public async Task ExecuteAsync(IProcessContext processContext)
        {
            InputBasket.TryGet(processContext, out var basket);
            OssBasketUni.TryGet(processContext, out var ossBasketUni);

            var log = processContext.ServiceProvider.GetService<ILogger>().ForContext<MapOssDataProcess>();
            var mapperFactory = processContext.ServiceProvider.GetService<IOssMapperFactory>();

            try
            {
                var number = basket.Number;
                var deal = basket.GetKaskoDeal();
                var mapper = mapperFactory.Create(ProductDictCodes.Kasko);
                var uni = DtoConverter.Convert(OssUniDeserializer.DeserializeToPolicy(ossBasketUni));

                // Добавляем для маппинга в осс
                if (uni.Policy.SpecialTerm != null)
                {
                    deal.EntityContext.Add("prevSpecialTerm", uni.Policy.SpecialTerm);
                }
                
                uni.Policy.Participants?.ForEach(participant => participant.SiebelId = null);
               
                var agentParticipants = uni.Policy.Participants.Where(x => new[] { 2, 3, 10 }.Contains(x.Role)).ToList();
                if (uni.Policy.Participants != null && agentParticipants.Any())
                {
                    deal.EntityContext.Add("agentParticipants", agentParticipants);
                }

                if (uni.Policy.Channel != null)
                {
                    deal.EntityContext.Add("prevChannel", uni.Policy.Channel);
                }

                if (uni.Policy.Kasko.SpecialProgram != null)
                {
                    deal.EntityContext.Add("prevSpecialProgram", uni.Policy.Kasko.SpecialProgram);
                }

                deal.EntityContext.Add("signDate", uni.Policy.Date);

                var processor = processContext.ServiceProvider.GetRequiredService<IOssKaskoOptionsProcessor>();
                var parser = processContext.ServiceProvider.GetService<IOssKaskoOptionsParser>();
                var ossKaskoOptions = parser.Parse(uni.Policy);
                var ossKaskoOptionsExcept = ossKaskoOptions.Except(deal.AutoDeal.PreviousOssOptions, new OssKaskoOptionsComparer());

                deal.AutoDeal.PreviousOssOptions.AddRange(ossKaskoOptionsExcept);

                processor.SetOssKaskoOptions(basket);
                
                await mapper.MapToDealAsync(uni, basket);

                deal.IsEPolicy = true;
                basket.Number = number;
            }
            catch (Exception ex)
            {
                log.Error(ex, "Произошла ошибка при маппинге данных из ОСС");
                throw;
            }
        }
    }
}
Как мне создать новый ProductRisk