namespace Bars.Alpha.Forms.Kb.EtlSteps.FormFilling.DSF

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text.RegularExpressions;

    using Bars.AKernel;

    using Bars.Alpha.Data.Impl;

    using Bars.Alpha.Forms.Kb.Utils;

    using Bars.Alpha.Meta;

    using Bars.Calculator.Impl;

    using Bars.Calculator.Impl.Conditions;

    using Bars.Calculator.Impl.Expressions;

    using Bars.Calculator.Impl.Functions;

    using Bars.Calculator.Impl.Functions.Table;

    using Bars.Calculator.Impl.Functions.Utils;

    using Bars.Calculator.Interfaces;

    using Bars.Common;

    using Bars.Etl.Core;

    using Bars.Etl.Steps;

​

    [Step("Заполнения формы ДСФ", "Заполнение форм")]

    internal class FoundsMoneysFilling : BaseFormFillingStep<EmptyStepData, EmptyStepData>

    {

        private List<string> groupingFieldList;

​

        private List<string> agregationFieldList;

​

        [StepConfig("Регулярное выражение для исключения форм по названию", 3)]

        public virtual LexemString ExcludeFormByNameRegEx { get; set; }

​

        /// <summary>

        /// Алгоритм построения запроса:

        /// 1. Ищем все хранилища форм по условию: есть поле "dim195193598_id"/* Версия бюджета */

        ///    и есть значения в строках этого поля, равные переданному значению в соответствующей переменной

        /// 2. Строим UNION ALL по всем найденным бизнес-объектам форм

        /// 3. Агрегируем суммой все значимые поля, группируем по размерностям и другим полям

        /// 4. Строим запрос, возвращающий нарастающую сумму по шагу планирования из агрегата

        /// 5. Строим запрос, возвращающий нарастающую сумму по шагу планирования со смещением на 1 шаг планирования вперед

        /// 6. Объединяем запросы (4) и (5) в общий запрос

        /// 7. Upsert

        /// </summary>

        protected override void ExecuteStep()

        {

            // Ищем все хранилища форм по условию (1)

            var storageMetadataList = this.GetSourceMetadataList();

​

            if (storageMetadataList.Any())

            {

                var encludedFroms = storageMetadataList

                    .Select(formStorage =>

                        string.Format("\"{0}\" ({1})", formStorage.Value, formStorage.Key.StorageName));

​

                this.Log(

                    string.Format(

                        "Выбраны формы для загрузки в ДСФ: {0}".L("ETL"),

                        string.Join(", ", encludedFroms)),

                    EtlLogType.Debug);

            }

​

            // Формируем UNION (2)

            IExpression fromUnionExpression = this.BuildUnionAllMetadatasExpression(storageMetadataList);

​

            this.agregationFieldList = this.ExtractValueFieldsFromStorageMetadata(this.GetMetadata());

​

            // Оборачиваем UNION запросы агрегацией по значимым полям и группировкой по размерностям (3)

            var unionGroupByExpression = this.BuildAgregateUnionExpression(fromUnionExpression);

            var fromAggregatedExpression = new FromExpression()

                .AddArgument(new AliasExpression(unionGroupByExpression, "t"));

​

            var articleDdsMetadata = this.GetMetadata(Constants.TypeIdArticleDds);

            var gettingUnitIdExpression = CalculatorExpressionHelper.GetIdSelectExpression(

                Constants.FieldCodeUnitName,

                Constants.DsfUnitName,

                this.GetMetadata(Constants.TypeIdUnit));

            var gettingAuditIdExpression = CalculatorExpressionHelper.GetIdSelectExpression(

                Constants.FieldCodeName,

                Constants.DsfAuditName,

                this.GetMetadata(Constants.TypeIdAudit));

​

            // Нарастающая сумма агрегирующих полей (4)

            var selectIncrementSumExpression = this.BuildSelectIncrementSum(

                (FromExpression)fromAggregatedExpression,

                new List<IExpression>

                {

                    new AliasExpression(gettingUnitIdExpression, Constants.CubeFieldCodeAdminCosts),

                    new AliasExpression(gettingAuditIdExpression, Constants.CubeFieldCodeAudit),

                    new AliasExpression(

                        CalculatorExpressionHelper.GetIdSelectExpression(

                            Constants.FieldCodeStateDdsNumber,

                            Constants.ArticleDdsFoundsMoney2,

                            articleDdsMetadata),

                        Constants.CubeFieldCodeArticleDds)

                });

​

            // Второй запрос нарастающей суммы со смещением на месяц вперед (5)

            var selectIncrementSumOffsetExpression = this.BuildSelectIncrementOffsetSum(

                (FromExpression)fromAggregatedExpression,

                new List<IExpression>

                {

                    new AliasExpression(gettingUnitIdExpression, Constants.CubeFieldCodeAdminCosts),

                    new AliasExpression(gettingAuditIdExpression, Constants.CubeFieldCodeAudit),

                    new AliasExpression(

                        CalculatorExpressionHelper.GetIdSelectExpression(

                            Constants.FieldCodeStateDdsNumber,

                            Constants.ArticleDdsFoundsMoney1,

                            articleDdsMetadata),

                        Constants.CubeFieldCodeArticleDds)

                });

​

            // Union этих запросов и обработка результата (6)

            var resultUnionExpression = new UnionExpression(

                selectIncrementSumExpression,

                selectIncrementSumOffsetExpression);

​

            // Upsert всех записей по ключам группировки (7)

            this.UpsertDataDocuments(resultUnionExpression, gettingUnitIdExpression, gettingAuditIdExpression);

        }

​

        /// <summary>

        /// Возвращает метаописание хранилища, по которому будет строиться запрос

        /// </summary>

        /// <returns></returns>

        protected override Metadata GetSourceMetadata()

        {

            // Вместо этого метода используется метод this.GetSourceMetadataList

            return null;

        }

​

        private void UpsertDataDocuments(

            IExpression resultExpression,

            SelectExpression gettingUnitIdExpression,

            SelectExpression gettingAuditIdExpression)

        {

            var keyFields = new List<string>

            {

                Constants.CubeFieldCodeArticleDds,

                Constants.CubeFieldCodeBudgetKind,

                Constants.CubeFieldCodeFinancingSources,

                Constants.FieldCodeYear

            };

​

            var constantFields = new Dictionary<string, IExpression>

            {

                { Constants.CubeFieldCodeBudgetVersion, new ConstantExpression(this.BudgetVersionIdValue) },

                {

                    Constants.CubeFieldCodeAdminCosts,

                    gettingUnitIdExpression

                },

                {

                    Constants.CubeFieldCodeAudit,

                    gettingAuditIdExpression

                }

            };

​

            this.UpsertDataDocuments(

                resultExpression,

                keyFields,

                constantFields);

        }

​

        /// <summary>

        /// Извлвекает все метаописания хранилищ форм,

        /// в записях которых встречается указанная версия бюджета

        /// </summary>

        /// <returns></returns>

        private Dictionary<Metadata, string> GetSourceMetadataList()

        {

            var resultList = new Dictionary<Metadata, string>();

​

            var formList = this.FormService.GetAll()

                .Where(form => form.Name != this.FormName)

                .ToList();

            this.Log(string.Format("Всего форм: {0}", formList.Count), EtlLogType.Debug);

​

            var excludedForms = new Dictionary<Metadata, string>();

            string regExString = this.ExcludeFormByNameRegEx;

            Regex excludingRegExp = null;

            try

            {

                excludingRegExp = new Regex(regExString);

            }

            catch (Exception exception)

            {

                this.Log(string.Format(

                    "Ошибка при построении регулярного выражения \"{0}\": {1}".L("ETL"),

                    regExString,

                    exception.Message));

            }

​

            foreach (var form in formList)

            {

                Metadata formStorageMetadata;

                if (form.MetadataId.HasValue)

                {

                    formStorageMetadata = this.ExtractStorageMetadataFromFormMetadata(form.MetadataId.Value, false);

                }

                else

                {

                    this.Log(

                        string.Format("У формы \"{0}\" нет ссылки на метаописание".L("ETL"), form.Name),

                        EtlLogType.Debug);

                    continue;

                }

​

                if (formStorageMetadata == null)

                {

                    this.Log(string.Format("У формы \"{0}\" нет метаописания".L("ETL"), form.Name), EtlLogType.Debug);

                    continue;

                }

​

                if (formStorageMetadata.FindField(Constants.CubeFieldCodeBudgetVersion) == null)

                {

                    this.Log(

                        string.Format(

                            "У формы \"{0}\" ({1}) нет поля версии бюджета".L("ETL"),

                            form.Name,

                            formStorageMetadata.StorageName),

                        EtlLogType.Debug);

​

                    continue;

                }

​

                var budgetVersionField = CalculatorExpressionHelper.GenerateAliasFieldExpression(

                    Constants.CubeFieldCodeBudgetVersion,

                    formStorageMetadata);

​

                var filterCondition = new ConditionAndExpression(

                    new EqualExpression(

                        budgetVersionField,

                        new ConstantExpression(this.BudgetVersionIdValue)));

                var selectExpression = new SkipTakeExpression()

                    .AddArgument(CalculatorExpressionHelper.GenerateQueryExpression(

                        formStorageMetadata,

                        this.MetadataService,

                        new List<AliasExpression> { budgetVersionField },

                        filterCondition))

                    .AddArgument(new ConstantExpression(0))

                    .AddArgument(new ConstantExpression(1));

​

                var resultDocument = this.DataDocumentService.GetAll(selectExpression, formStorageMetadata)

                    .FirstOrDefault();

​

                if (resultDocument == null)

                {

                    var logMessage = string.Format(

                        "У формы \"{0}\" ({1}) нет записей с указанной версией бюджета".L("ETL"),

                        form.Name,

                        formStorageMetadata.StorageName);

                    this.Log(

                        logMessage,

                        EtlLogType.Debug);

​

                    continue;

                }

​

                if (excludingRegExp != null && excludingRegExp.IsMatch(form.Name))

                {

                    excludedForms[formStorageMetadata] = form.Name;

                }

                else

                {

                    resultList[formStorageMetadata] = form.Name;

                }

            }

​

            if (excludedForms.Any())

            {

                var excludedFormList =

                    excludedForms.Select(

                        excludedForm => string.Format("\"{0}\" ({1})", excludedForm.Value, excludedForm.Key.StorageName));

                this.Log(string.Format("Исключенные формы: {0}".L("ETL"), string.Join(", ", excludedFormList)));

            }

​

            return resultList;

        }

​

        /// <summary>

        /// Собирает мегаUnionЗапрос из списка метаописаний хранилищ,

        /// которые выбраны методом <see cref="GetSourceMetadataList"/>

        /// </summary>

        /// <param name="storageMetadataList">Список метаописаний хранилищ форм ввода</param>

        /// <returns></returns>

        private UnionExpression BuildUnionAllMetadatasExpression(Dictionary<Metadata, string> storageMetadataList)

        {

            var selectExpressionList = new List<IExpression>();

            var destinationValueFieldList = this.ExtractValueFieldsFromStorageMetadata(this.GetMetadata());

​

            var budgetKindMeta = this.GetMetadata(Constants.TypeIdBudgetKind);

            var auditMeta = this.GetMetadata(Constants.TypeIdAudit);

            var articleDdsMeta = this.GetMetadata(Constants.TypeIdArticleDds);

            foreach (var storageMetadata in storageMetadataList.Keys)

            {

                // Выбираем значимые поля из источника и подставляем алиас приемника (ДСФ)

                var fieldCodeList = this.ExtractValueFieldsFromStorageMetadata(storageMetadata);

                List<AliasExpression> aliasFieldList;

                try

                {

                    aliasFieldList = this.CombineSourceToDestinationFields(

                        fieldCodeList,

                        destinationValueFieldList,

                        storageMetadata);

                }

                catch (Exception exception)

                {

                    this.Log(string.Format(

                        "Для хранилища формы \"{0}\" ({2}) при формировании полей обнаружена ошибка \"{1}\"".L("ETL"),

                        storageMetadataList[storageMetadata],

                        exception.Message,

                        storageMetadata.StorageName));

                    continue;

                }

​

                // Добавляем поля размерностей

                var resultFields = this.GetGroupingFieldList()

                    .Select(x => this.GenerateAliasFieldExpression(x, sourceMetadata: storageMetadata))

                    .ToList();

​

                // Добавляем аудит для построения запроса

                resultFields.Add(this.GenerateAliasFieldExpression(

                    Constants.CubeFieldCodeAudit,

                    sourceMetadata: storageMetadata));

​

                resultFields.AddRange(aliasFieldList);

​

                // Фильтруем по виду бюджета, аудиту и версии бюджета

                var filterBudgetKindExpression = new InExpression()

                    .AddArgument(

                        new AliasExpression(Constants.CubeFieldCodeBudgetKind))

                    .AddArgument(

                        CalculatorExpressionHelper.GetIdSelectExpression(

                            Constants.FieldCodeScenarioName,

                            new List<object>

                            {

                                Constants.DsfBudgetKindCurrent,

                                Constants.DsfBudgetKindAdditionalCosts

                            },

                            budgetKindMeta));

​

                var includeAudits = new List<object>

                {

                    Constants.AuditAutofilling,

                    Constants.AuditFilling,

                    Constants.AuditBuildingCostsDistribution,

                    Constants.AuditExhibitionCostsDistribution

                };

                var filterAuditExpression = new InExpression()

                    .AddArgument(

                        new AliasExpression(Constants.CubeFieldCodeAudit))

                    .AddArgument(

                        CalculatorExpressionHelper.GetIdSelectExpression(

                            Constants.FieldCodeName,

                            includeAudits,

                            auditMeta));

​

                var filterBudgetVersionExpression = new EqualExpression(

                    new AliasExpression(Constants.CubeFieldCodeBudgetVersion),

                    new ConstantExpression(this.BudgetVersionIdValue));

​

                // Также исключаем статьи, начинающиеся на "0"

                var articleDdsExludeExpression = new NotExpression(new InExpression()

                    .AddArgument(new AliasExpression(Constants.CubeFieldCodeArticleDds))

                    .AddArgument(CalculatorExpressionHelper.GetIdSelectExpression(

                        Constants.FieldCodeStateDdsNumber,

                        "0",

                        articleDdsMeta,

                        equalType: "like%")));

​

                var filterCondition = new ConditionAndExpression()

                    .AddArgument(filterBudgetKindExpression)

                    .AddArgument(filterAuditExpression)

                    .AddArgument(filterBudgetVersionExpression)

                    .AddArgument(articleDdsExludeExpression);

​

                // Учитываем версионность - выбираем только актуальные данные

                if (storageMetadata.IsVersionMetaStorage)

                {

                    filterCondition.AddArgument(CalculatorExpressionHelper.BuildVersionBetweenExpression(

                        storageMetadata,

                        "t"));

                }

​

                try

                {

                    var selectExpression = CalculatorExpressionHelper.GenerateQueryExpression(

                        storageMetadata,

                        this.MetadataService,

                        resultFields,

                        filterCondition);

​

                    // Удаляем аудит, чтоб по нему не прошла группировка

                    selectExpression.Arguments.RemoveAt(this.GetGroupingFieldList().Count + 1);

​

                    selectExpressionList.Add(selectExpression);

                }

                catch (Exception exception)

                {

                    this.Log(string.Format(

                        "Для хранилища формы \"{0}\" ({2}) при формировании запроса обнаружена ошибка \"{1}\"".L("ETL"),

                        storageMetadataList[storageMetadata],

                        exception.Message,

                        storageMetadata.StorageName));

                }

            }

​

            return new UnionExpression(selectExpressionList.ToArray());

        }

​

        /// <summary>

        /// Строим агрегацию по значимым полям из данных мегаUnionЗапроса,

        /// который построен методом <see cref="BuildUnionAllMetadatasExpression"/>

        /// </summary>

        /// <param name="fromUnionExpression">мегаUnionЗапрос</param>

        /// <returns></returns>

        private BaseFunctionalExpression BuildAgregateUnionExpression(IExpression fromUnionExpression)

        {

            var finansingSourceFromExpression = new FromExpression()

                .AddArgument(new AliasExpression(this.GetMetadata(Constants.TypeIdFinancingSources), "fs"));

​

            fromUnionExpression = new JoinExpression(

                "inner",

                finansingSourceFromExpression,

                new AliasExpression(fromUnionExpression, "t"),

                new EqualExpression(

                    new NativeExpression(string.Format("fs.\"{0}\"", Constants.FieldCodeId)),

                    new NativeExpression(string.Format("t.\"{0}\"", Constants.CubeFieldCodeFinancingSources))));

​

            var agregationSelectExpression = new SelectExpression()

                .AddArgument(fromUnionExpression);

​

            this.GetGroupingFieldList().ForEach(field => agregationSelectExpression

                .AddArgument(new NativeExpression(string.Format("t.\"{0}\"", field))));

​

            // Баланс источника финансирования на начало периода

            agregationSelectExpression

                .AddArgument(new NativeExpression(string.Format("fs.\"{0}\"", Constants.FieldCodeBalance)));

​

            this.agregationFieldList.ForEach(field =>

                agregationSelectExpression

                    .AddArgument(new AliasExpression(

                        new AggregateExpression()

                            .AddArguments(

                                new NativeExpression("SUM"),

                                new NativeExpression(string.Format("t.\"{0}\"", field))),

                        string.Format("\"{0}\"", field))));

​

            return new GroupByExpression().AddArguments(

                agregationSelectExpression,

                new ConstantExpression(1),

                new ConstantExpression(2),

                new ConstantExpression(3),

                new ConstantExpression(4),

                new ConstantExpression(5));

        }

​

        /// <summary>

        /// Строит запрос нарастающей суммы по шагам планирования из данных запроса,

        /// построенного методом <see cref="BuildAgregateUnionExpression"/>.

        /// Нарастающая сумма:

        /// * 1 шаг планирования = балланс на начало текущего периода + 1 шаг планирования

        /// * 2 шаг планирования = (балланс на начало текущего периода) + 1 шаг планирования + 2 шаг планирования

        /// ...

        /// </summary>

        /// <param name="fromAggregatedExpression"></param>

        /// <param name="constantFieldExpressions"></param>

        /// <returns></returns>

        private IExpression BuildSelectIncrementSum(

            FromExpression fromAggregatedExpression,

            List<IExpression> constantFieldExpressions)

        {

            var selectIncrementSumExpression = new SelectExpression(true)

                .AddArgument(fromAggregatedExpression);

​

            this.GetGroupingFieldList().ForEach(

                field => selectIncrementSumExpression.AddArgument(string.Format("t.\"{0}\"", field)));

​

            // Формируем нарастающую сумму: для каждого поля-значения будем 

            // добавлять его в список и формировать сумму по полям этого списка

            var incrementSumFields = new List<string>

            {

                string.Format("t.\"{0}\"", Constants.FieldCodeBalance)

            };

            selectIncrementSumExpression

                .AddArgument(new NativeExpression(string.Format("t.\"{0}\"", Constants.FieldCodeBalance)));

​

            this.agregationFieldList.ForEach(field =>

            {

                incrementSumFields.Add(string.Format("t.\"{0}\"", field));

​

                var sumFields = string.Join(" + ", incrementSumFields);

                selectIncrementSumExpression

                    .AddArgument(new NativeExpression(string.Format("{0} AS \"{1}\"", sumFields, field)));

            });

​

            // Добавляем константные поля

            selectIncrementSumExpression.AddArguments(constantFieldExpressions);

​

            return selectIncrementSumExpression;

        }

​

        /// <summary>

        /// Строит запрос нарастающей суммы по шагам планирования со смещением из данных запроса,

        /// построенного методом <see cref="BuildAgregateUnionExpression"/>.

        /// Нарастающая сумма:

        /// * 1 шаг планирования = балланс на начало текущего периода

        /// * 2 шаг планирования = (балланс на начало текущего периода) + 1 шаг планирования

        /// * 3 шаг планирования = (балланс на начало текущего периода) + 1 шаг планирования + 2 шаг планирования

        /// ...

        /// </summary>

        /// <param name="fromAggregatedExpression"></param>

        /// <param name="constantFieldExpressions"></param>

        /// <returns></returns>

        private IExpression BuildSelectIncrementOffsetSum(

            FromExpression fromAggregatedExpression,

            List<IExpression> constantFieldExpressions)

        {

            var selectIncrementSumOffsetExpression = new SelectExpression(true)

                .AddArgument(fromAggregatedExpression);

            this.GetGroupingFieldList().ForEach(

                field => selectIncrementSumOffsetExpression.AddArgument(string.Format("t.\"{0}\"", field)));

​

            // Формируем нарастающую сумму: для каждого поля-значения будем 

            // добавлять его в список и формировать сумму по полям этого списка

            var incrementSumOffsetFields = new List<string>

            {

                string.Format("t.\"{0}\"", Constants.FieldCodeBalance)

            };

            selectIncrementSumOffsetExpression

                .AddArgument(new NativeExpression(string.Format("t.\"{0}\"", Constants.FieldCodeBalance)));

​

            this.agregationFieldList.ForEach(field =>

            {

                var sumFields = string.Join(" + ", incrementSumOffsetFields);

                selectIncrementSumOffsetExpression

                    .AddArgument(new NativeExpression(string.Format("{0} AS \"{1}\"", sumFields, field)));

​

                incrementSumOffsetFields.Add(string.Format("t.\"{0}\"", field));

            });

​

            // Добавляем константные поля

            selectIncrementSumOffsetExpression.AddArguments(constantFieldExpressions);

​

            return selectIncrementSumOffsetExpression;

        }

​

        private List<string> GetGroupingFieldList()

        {

            return this.groupingFieldList ??

                   (this.groupingFieldList = new List<string>

                   {

                       Constants.CubeFieldCodeBudgetKind,

                       Constants.CubeFieldCodeFinancingSources,

                       Constants.CubeFieldCodeBudgetVersion,

                       Constants.FieldCodeYear

                   });

        }

​

        private List<string> ExtractValueFieldsFromStorageMetadata(Metadata storageMetadata)

        {

            var flattenValueFields = storageMetadata.FlattenFields()

                .Where(field => (field.Field.Code == "summh" ||

                                 field.Field.Code == "price") &&

                                (field.Field.FieldType == FieldType.Double ||

                                 field.Field.FieldType == FieldType.Currency));

​

            return flattenValueFields.Select(field => field.CodePath).ToList();

        }

​

        private List<AliasExpression> CombineSourceToDestinationFields(

            List<string> sourceFields,

            List<string> destinationFieldsAlias,

            Metadata storageMetadata)

        {

            if (sourceFields.Count != destinationFieldsAlias.Count)

            {

                throw new Exception("Неверно выбран горизонт планирования и шаг планирования".L("ETL"));

            }

​

            var result = new List<AliasExpression>();

​

            for (var i = 0; i < sourceFields.Count; i++)

            {

                // Формируем конструкцию типа (CASE WHEN "Tip_stat" = 'Рсх' THEN (- 1) ELSE 1 END) * coalesce("col35.col40.col43.kolvo" * "col35.col40.col43.price", 0)

                var conditionExpression = new ConditionExpression();

                conditionExpression.AddArgument(new EqualExpression(

                    this.GenerateAliasFieldExpression("dim9322_id.Dhd_Rskh.Tip_stat", sourceMetadata: storageMetadata),

                    new ConstantExpression(Constants.DsfExpenseArticleType)));

                conditionExpression.AddArgument(new ConstantExpression(-1));

​

                // TODO (i.gusev) по идее тут правильнее проверять на "Дхд"

                conditionExpression.AddArgument(new ConstantExpression(1));

​

                // Разделяем образование полей summh и kolvo*price

                var valueFieldExpression = new CoalesceExpression();

                if (sourceFields[i].EndsWith(Constants.FieldCodeDestinationValue))

                {

                    valueFieldExpression.AddArgument(this.GenerateAliasFieldExpression(

                        string.Format("\"{0}\"", sourceFields[i]),

                        sourceMetadata: storageMetadata));

                }

                else

                {

                    var kolvoPriceMultiplicationExpression = new MultiplicationExpression();

                    var lastPointIndex = sourceFields[i].LastIndexOf(".", StringComparison.Ordinal);

                    var kolvoFieldCode = string.Format("{0}.kolvo", sourceFields[i].Substring(0, lastPointIndex));

                    kolvoPriceMultiplicationExpression.AddArgument(this.GenerateAliasFieldExpression(

                        string.Format("\"{0}\"", sourceFields[i]),

                        sourceMetadata: storageMetadata));

​

                    kolvoPriceMultiplicationExpression.AddArgument(this.GenerateAliasFieldExpression(

                        string.Format("\"{0}\"", kolvoFieldCode),

                        sourceMetadata: storageMetadata));

​

                    valueFieldExpression.AddArgument(kolvoPriceMultiplicationExpression);

                }

​

                valueFieldExpression.AddArgument(new ConstantExpression(0));

​

                var multiplicationExpresison = new MultiplicationExpression();

                multiplicationExpresison.AddArgument(conditionExpression);

                multiplicationExpresison.AddArgument(valueFieldExpression);

​

                result.Add(new AliasExpression(multiplicationExpresison, destinationFieldsAlias[i]));

            }

​

            return result;

        }

    }

}