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

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using Bars.AKernel;

    using Bars.Alpha.Data.Impl;

    using Bars.Alpha.DataAccess;

    using Bars.Alpha.Dictionary;

    using Bars.Alpha.Forms.Kb.Utils;

    using Bars.Alpha.Meta;

    using Bars.Alpha.Meta.Fields;

    using Bars.Calculator.Impl;

    using Bars.Calculator.Impl.Conditions;

    using Bars.Calculator.Impl.Expressions;

    using Bars.Calculator.Impl.Functions;

    using Bars.Calculator.Impl.Functions.Date;

    using Bars.Calculator.Impl.Functions.Table;

    using Bars.Calculator.Impl.Functions.Utils;

    using Bars.Etl.Core;

​

    [Step("Реализация НА", "Заполнение форм")]

    internal class NaRealizationFilling : BaseSummhPeriodFieldGenerateStep

    {

        private readonly List<string> ignoreFieldsNamesList = new List<string>

        {

            "_Source",

            "IsReadOnly",

            "ChangedBy",

            "ActualId",

            "DateBegin",

            "DateEnd",

            "VersionId",

            "VersionType"

        };

​

        private const string FormTableAlias = "form";

        private const string TypeOperacName = "TypeOperac";

        private const string TypeOperacAlias = "typeop";

        private const string TipStatName = "Tip_stat";

        private const string TipStatAlias = "ts";

        private const string Storno = "Сторно";

​

        private const string Income = "Дхд";

        private const string Outgo = "Рсх";

​

        private Metadata formTableMetadata;

        private Metadata auditMetadata;

        private Metadata typeOperacMetadata;

        private Metadata statDdsMetadata;

        private Metadata tipStatMetadata;

​

        private string formTableName;

​

        protected override void ExecuteStep()

        {

            this.formTableName = this.FormStorageMetadata.StorageName;

​

            this.formTableMetadata = this.FormStorageMetadata;

            this.auditMetadata = this.GetMetadata(Constants.TypeIdAudit);

            this.typeOperacMetadata = this.GetMetadata(NaRealizationFilling.TypeOperacName);

            this.statDdsMetadata = this.GetMetadata(Constants.TypeIdArticleDds);

            this.tipStatMetadata = this.GetMetadata(NaRealizationFilling.TipStatName);

​

            var destinationFields =

                this.GetMetadata()

                    .FlattenFields()

                    .Where(

                        x =>

                            !x.Field.GetIsCalculated() && x.Field.FieldType != FieldType.ReferenceObject &&

                            x.Field.FieldType != FieldType.ReferenceTable);

​

            var agregatFromExpression = new FromExpression().AddArgument(

                    new AliasExpression(this.formTableName, NaRealizationFilling.FormTableAlias));

​

            var agregatFirstJoinConditionExpression = new EqualExpression(

                new FieldExpression("dim195349114_id", this.formTableMetadata, NaRealizationFilling.FormTableAlias),

                new FieldExpression("id", this.typeOperacMetadata, NaRealizationFilling.TypeOperacAlias));

​

            var agregatFirstJoinExpression = new JoinExpression("INNER",

                agregatFromExpression,

                new AliasExpression(

                    this.typeOperacMetadata,

                    NaRealizationFilling.TypeOperacAlias),

                agregatFirstJoinConditionExpression);

​

            var agregatSecondJoinFirstConditionExpression = new EqualExpression(

                new FieldExpression("id", this.tipStatMetadata, NaRealizationFilling.TipStatAlias),

                new FieldExpression("incomecosts", this.typeOperacMetadata, NaRealizationFilling.TypeOperacAlias));

​

            var agregatSecondJoinSecondConditionFirstVariableExpression = new EqualExpression(

                new FieldExpression(NaRealizationFilling.TipStatName,

                    this.tipStatMetadata,

                    NaRealizationFilling.TipStatAlias),

                new ConstantExpression(NaRealizationFilling.Income));

​

            var agregatSecondJoinSecondConditionSecondVariableExpression = new EqualExpression(

                new FieldExpression(NaRealizationFilling.TipStatName,

                    this.tipStatMetadata,

                    NaRealizationFilling.TipStatAlias),

                new ConstantExpression(NaRealizationFilling.Outgo));

​

            var agregatSecondJoinSecondConditionExpression = new ConditionOrExpression()

                .AddArguments(

                    agregatSecondJoinSecondConditionFirstVariableExpression,

                    agregatSecondJoinSecondConditionSecondVariableExpression);

​

            var agregatSecondJoinConditionAndExpression =

                new ConditionAndExpression(agregatSecondJoinFirstConditionExpression,

                    agregatSecondJoinSecondConditionExpression);

​

            var agregatSecondJoinExpression = new JoinExpression("INNER",

                agregatFirstJoinExpression,

                new AliasExpression(this.tipStatMetadata, NaRealizationFilling.TipStatAlias),

                agregatSecondJoinConditionAndExpression);

​

            var agregatInExpression = new InExpression()

                .AddArguments(new FieldExpression(

                    Constants.CubeFieldCodeAudit,

                    this.formTableMetadata,

                    NaRealizationFilling.FormTableAlias),

                    CalculatorExpressionHelper.GetIdSelectExpression(

                        Constants.FieldCodeName,

                        "Заполнение",

                        this.auditMetadata));

​

            var agregatBetweenExpression = new BetweenExpression()

                .AddArgument(new DateToUTCExpression().AddArgument(new NowExpression()))

                .AddArgument(new FieldExpression(Constants.FieldCodeDateBegin,

                    this.formTableMetadata,

                    NaRealizationFilling.FormTableAlias))

                .AddArgument(new FieldExpression(Constants.FieldCodeDateEnd,

                    this.formTableMetadata,

                    NaRealizationFilling.FormTableAlias));

​

            var agregatAndExpression = new ConditionAndExpression(agregatInExpression, agregatBetweenExpression);

​

            var agregatFilterExpression = new FilterExpression(agregatSecondJoinExpression, agregatAndExpression);

​

            var agregatSelectExpression = new SelectExpression(true).AddArgument(agregatFilterExpression);

​

            foreach (var field in destinationFields.Where(field => !this.ignoreFieldsNamesList.Contains(field.CodePath)))

            {

                switch (field.CodePath)

                {

                    // аудит

                    case Constants.CubeFieldCodeAudit:

                        var auditIdSelectExpression = CalculatorExpressionHelper.GetIdSelectExpression(

                            Constants.FieldCodeName,

                            "Распределение ДС от РНА",

                            this.auditMetadata);

​

                        agregatSelectExpression.AddArgument(

                            new AliasExpression(auditIdSelectExpression, Constants.CubeFieldCodeAudit));

                        break;

                    // Тип операции

                    case "dim195349114_id":

                        var typeOperacIdSelectExpression = CalculatorExpressionHelper.GetIdSelectExpression(

                            "NameTypeOper",

                            "Не выбрано",

                            this.typeOperacMetadata);

​

                        agregatSelectExpression.AddArgument(

                            new AliasExpression(typeOperacIdSelectExpression, "dim195349114_id"));

                        break;

                    // проценты

                    case "precent":

                        agregatSelectExpression.AddArgument(

                            new AliasExpression(new NativeExpression("NULL::DOUBLE PRECISION"), "precent"));

                        break;

                    // статья ДДС

                    case Constants.CubeFieldCodeArticleDds:

                        agregatSelectExpression.AddArguments(

                            new AliasExpression(CalculatorExpressionHelper.GetIdSelectExpression(

                                Constants.FieldCodeStateDdsNumber,

                                "0.3",

                                this.statDdsMetadata),

                                Constants.CubeFieldCodeArticleDds));

                        break;

                    default:

                        if (field.CodePath.StartsWith("col") || field.CodePath.StartsWith("scol"))

                        {

                            var fieldExpression = new FieldExpression(field.CodePath,

                                this.formTableMetadata,

                                NaRealizationFilling.FormTableAlias);

​

                            var miltiplication = new MultiplicationExpression();

                            miltiplication.AddArgument(fieldExpression);

                            miltiplication.AddArgument(new NativeExpression("-1"));

​

                            var subcondition = new ConditionExpression().AddArguments(

                                new EqualExpression(

                                    new FieldExpression(NaRealizationFilling.TipStatName,

                                        this.tipStatMetadata,

                                        NaRealizationFilling.TipStatAlias),

                                    new ConstantExpression(NaRealizationFilling.Outgo)),

                                fieldExpression, new NativeExpression("NULL"));

​

                            var condition = new ConditionExpression().AddArguments(

                                new EqualExpression(

                                    new FieldExpression(NaRealizationFilling.TipStatName,

                                        this.tipStatMetadata,

                                        NaRealizationFilling.TipStatAlias),

                                    new ConstantExpression(NaRealizationFilling.Income)),

                                miltiplication,

                                subcondition);

​

                            var aggregation = new AggregateExpression();

​

                            if (field.CodePath.EndsWith(Constants.FieldCodeDestinationValue))

                            {

​

                                aggregation.AddArguments(

                                    new NativeExpression("SUM"),

                                    condition);

                            }

                            else

                            {

                                aggregation.AddArguments(

                                    new NativeExpression("MAX"),

                                    fieldExpression);

                            }

​

​

                            agregatSelectExpression.AddArgument(new AliasExpression(aggregation, field.CodePath));

                        }

                        else

                        {

                            agregatSelectExpression.AddArgument(new FieldExpression(field.CodePath,

                                this.formTableMetadata,

                                NaRealizationFilling.FormTableAlias));

                        }

                        break;

                }

            }

​

            var agregatGroupByExpression = new GroupByExpression().AddArgument(

                agregatSelectExpression).AddArguments(this.GenerateGroupingFields());

​

            var data = this.DataDocumentService.GetAll(agregatGroupByExpression, this.GetMetadata()).ToList();

        }

​

        /// <summary>

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

        /// </summary>

        /// <returns></returns>

        protected override Metadata GetSourceMetadata()

        {

            return this.GetMetadata();

        }

​

        protected override bool IsNeedPeriodFieldCodeInit

        {

            get { return false; }

        }

​

        protected override string ScenaryFieldName

        {

            get { return null; }

        }

​

        protected override string SourceCurrencyFieldCode

        {

            get { return null; }

        }

​

        private IEnumerable<FieldExpression> GenerateGroupingFields()

        {

            return new List<FieldExpression>

            {

                // Валюта служебная

                new FieldExpression(Constants.CubeFieldCodeEntryCurrency,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Направление расходов

                new FieldExpression("NaprRash",

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Версия бюджета

                new FieldExpression(Constants.CubeFieldCodeBudgetVersion,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Вид бюджета

                new FieldExpression(Constants.CubeFieldCodeBudgetKind,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Администратор доходов расходов

                new FieldExpression(Constants.CubeFieldCodeAdminCosts,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Инициирующее подразделение

                new FieldExpression(Constants.CubeFieldCodeInitiationDepartment,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Непрофильные активы

                new FieldExpression("dim195374841_id", 

                this.formTableMetadata, 

                NaRealizationFilling.FormTableAlias),

​

                // Источик финансирования

                new FieldExpression(Constants.CubeFieldCodeFinancingSources,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Валюта ввода

                new FieldExpression(Constants.FieldCodeBaseCurrency,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

​

                // Год

                new FieldExpression(Constants.FieldCodeYear, 

                this.formTableMetadata, 

                NaRealizationFilling.FormTableAlias),

​

                // Комментарий

                new FieldExpression(Constants.FieldCodeComment,

                this.formTableMetadata,

                NaRealizationFilling.FormTableAlias),

            };

        }

    }

}