internal FixedList <TrialBalanceEntry> GetPostingEntries(bool isComparativeBalance = false)
        {
            var helper = new TrialBalanceHelper(_command);

            TrialBalanceCommandPeriod commandPeriod = new TrialBalanceCommandPeriod();

            if (isComparativeBalance)
            {
                commandPeriod = _command.FinalPeriod;
            }
            else
            {
                commandPeriod = _command.InitialPeriod;
            }

            FixedList <TrialBalanceEntry> postingEntries = helper.GetTrialBalanceEntries(commandPeriod);

            if (_command.ValuateBalances || _command.ValuateFinalBalances)
            {
                postingEntries = helper.ValuateToExchangeRate(postingEntries, commandPeriod);

                if (_command.ConsolidateBalancesToTargetCurrency)
                {
                    postingEntries = helper.ConsolidateToTargetCurrency(postingEntries, commandPeriod);
                }
            }
            return(postingEntries);
        }
        internal FixedList <TrialBalanceEntry> ConsolidateToTargetCurrency(
            FixedList <TrialBalanceEntry> trialBalance,
            TrialBalanceCommandPeriod commandPeriod)
        {
            var targetCurrency = Currency.Parse(commandPeriod.ValuateToCurrrencyUID);

            var summaryEntries = new EmpiriaHashTable <TrialBalanceEntry>();

            foreach (var entry in trialBalance)
            {
                string hash = $"{entry.Account.Number}||{entry.Sector.Code}||{targetCurrency.Id}||{entry.Ledger.Id}";

                if (entry.Currency.Equals(targetCurrency))
                {
                    summaryEntries.Insert(hash, entry);
                }
                else if (summaryEntries.ContainsKey(hash))
                {
                    summaryEntries[hash].Sum(entry);
                }
                else
                {
                    entry.Currency = targetCurrency;
                    summaryEntries.Insert(hash, entry);
                }
            }

            return(summaryEntries.Values.ToList()
                   .ToFixedList());
        }
        internal FixedList <TrialBalanceEntry> GetTrialBalanceEntries(TrialBalanceCommandPeriod commandPeriod)
        {
            if (_command.TrialBalanceType == TrialBalanceType.SaldosPorCuentaYMayor ||
                _command.TrialBalanceType == TrialBalanceType.BalanzaValorizadaComparativa)
            {
                _command.ShowCascadeBalances = true;
            }

            TrialBalanceCommandData commandData = _command.MapToTrialBalanceCommandData(commandPeriod);

            return(TrialBalanceDataService.GetTrialBalanceEntries(commandData));
        }
        internal FixedList <TrialBalanceEntry> ValuateToExchangeRate(FixedList <TrialBalanceEntry> entries,
                                                                     TrialBalanceCommandPeriod commandPeriod)
        {
            var exchangeRateType = ExchangeRateType.Parse(commandPeriod.ExchangeRateTypeUID);

            FixedList <ExchangeRate> exchageRates = ExchangeRate.GetList(exchangeRateType, commandPeriod.ExchangeRateDate);

            foreach (var entry in entries.Where(a => a.Currency.Code != "01"))
            {
                var exchangeRate = exchageRates.FirstOrDefault(a => a.FromCurrency.Code == commandPeriod.ValuateToCurrrencyUID &&
                                                               a.ToCurrency.Code == entry.Currency.Code);

                Assertion.AssertObject(exchangeRate, $"No hay tipo de cambio para la moneda {entry.Currency.FullName}.");

                entry.MultiplyBy(exchangeRate.Value);
            }
            return(entries);
        }