static private FixedList <ITrialBalanceEntryDto> Map(TrialBalanceCommand command,
FixedList <ITrialBalanceEntry> list)
{
switch (command.TrialBalanceType)
{
case TrialBalanceType.AnaliticoDeCuentas:
var mi = list.Select((x) => MapToTwoCurrenciesBalanceEntry((TwoCurrenciesBalanceEntry)x));
return(new FixedList <ITrialBalanceEntryDto>(mi));
case TrialBalanceType.Balanza:
case TrialBalanceType.BalanzaConAuxiliares:
case TrialBalanceType.GeneracionDeSaldos:
case TrialBalanceType.Saldos:
case TrialBalanceType.SaldosPorAuxiliar:
case TrialBalanceType.SaldosPorCuenta:
case TrialBalanceType.SaldosPorCuentaYMayor:
var mappedItems = list.Select((x) => MapToTrialBalance((TrialBalanceEntry)x));
return(new FixedList <ITrialBalanceEntryDto>(mappedItems));
case TrialBalanceType.BalanzaValorizadaComparativa:
var mappedItemsComparative = list.Select((x) => MapToTrialBalanceComparative((TrialBalanceEntry)x));
return(new FixedList <ITrialBalanceEntryDto>(mappedItemsComparative));
default:
throw Assertion.AssertNoReachThisCode(
$"Unhandled trial balance type {command.TrialBalanceType}.");
}
}
public CollectionModel GetGridFormDataSource([FromUri] string dataObjectUID,
[FromUri] string activityUID)
{
try {
var dataObject = StepDataObject.Parse(dataObjectUID);
var activity = ProjectItem.Parse(activityUID);
FixedList <Posting> list = PostingList.GetPostings(dataObject.DataItem,
activity,
dataObject.DataItem.DataType);
var data = list.Select(x => {
var json = x.ExtensionData.ToDictionary();
json.Add("uid", x.UID);
if (dataObject.DataItem.Terms == "Actividades.CNH.CustomGrid")
{
json = Reporting.SubtaskCNH.LoadFields(dataObject, json, activity);
}
return(json);
});
return(new CollectionModel(this.Request, data.ToArray()));
} catch (Exception e) {
throw base.CreateHttpException(e);
}
}
public FixedList <AccountsChartMasterDataDto> GetAccountsChartsMasterData()
{
FixedList <AccountsChart> accountsChartsList = AccountsChart.GetList();
var masterDataList = new FixedList <AccountsChartMasterData>(accountsChartsList.Select(x => x.MasterData));
return(AccountsChartMasterDataMapper.Map(masterDataList));
}
internal TrialBalance BuildForBalancesGeneration()
{
var helper = new TrialBalanceHelper(_command);
FixedList <TrialBalanceEntry> trialBalance = helper.GetPostingEntries();
var returnBalance = new FixedList <ITrialBalanceEntry>(trialBalance.Select(x => (ITrialBalanceEntry)x));
return(new TrialBalance(_command, returnBalance));
}
internal TrialBalance Build()
{
var helper = new TrialBalanceHelper(_command);
var twoColumnsHelper = new TwoCurrenciesBalanceHelper(_command);
FixedList <TrialBalanceEntry> postingEntries = helper.GetTrialBalanceEntries(_command.InitialPeriod);
postingEntries = helper.ValuateToExchangeRate(postingEntries, _command.InitialPeriod);
List <TrialBalanceEntry> summaryEntries = helper.GenerateSummaryEntries(postingEntries);
List <TrialBalanceEntry> trialBalance = helper.CombineSummaryAndPostingEntries(summaryEntries,
postingEntries);
trialBalance = helper.RestrictLevels(trialBalance);
FixedList <TwoCurrenciesBalanceEntry> twoColumnsEntries =
twoColumnsHelper.MergeAccountsIntoTwoColumns(trialBalance);
FixedList <TwoCurrenciesBalanceEntry> summaryGroupEntries =
twoColumnsHelper.GetTotalSummaryGroup(twoColumnsEntries);
twoColumnsEntries = twoColumnsHelper.CombineGroupEntriesAndTwoColumnsEntries(
twoColumnsEntries, summaryGroupEntries);
List <TwoCurrenciesBalanceEntry> summaryTotalDeptorCreditorEntries =
twoColumnsHelper.GetTotalDeptorCreditorTwoColumnsEntries(
twoColumnsEntries);
twoColumnsEntries = twoColumnsHelper.CombineTotalDeptorCreditorAndTwoColumnsEntries(
twoColumnsEntries.ToList(), summaryTotalDeptorCreditorEntries);
List <TwoCurrenciesBalanceEntry> summaryTwoColumnsBalanceTotal =
twoColumnsHelper.GenerateTotalSummary(summaryTotalDeptorCreditorEntries);
twoColumnsEntries = twoColumnsHelper.CombineTotalConsolidatedAndPostingEntries(
twoColumnsEntries, summaryTwoColumnsBalanceTotal);
FixedList <ITrialBalanceEntry> twoColumnsBalance = twoColumnsEntries.Select(x => (ITrialBalanceEntry)x)
.ToList().ToFixedList();
return(new TrialBalance(_command, twoColumnsBalance));
}
static private FixedList <AccountHistoryDto> MapAccountHistory(FixedList <Account> list)
{
return(new FixedList <AccountHistoryDto>(list.Select((x) => MapToAccountHistory(x))));
}
static internal FixedList <ExchangeRateDto> Map(FixedList <ExchangeRate> list)
{
return(new FixedList <ExchangeRateDto>(list.Select((x) => Map(x))));
}
static internal FixedList <SignEventDTO> Map(FixedList <SignEvent> source)
{
return(new FixedList <SignEventDTO>(source.Select((x) => Map(x))));
}
static private FixedList <InitialBalanceEntryDto> Map(FixedList <InitialBalanceEntry> list)
{
var mappedItems = list.Select((x) => Map(x));
return(new FixedList <InitialBalanceEntryDto>(mappedItems));
}
static internal FixedList <SubsidiaryAccountDto> Map(FixedList <SubsidiaryAccount> list)
{
return(new FixedList <SubsidiaryAccountDto>(list.Select(x => MapAccount(x))));
}
private ArrayList ToProductTermModel(FixedList<ProductTerm> list) {
return new ArrayList(list.Select((x) => ToProductTermModel(x)).ToArray());
}
static internal FixedList <VoucherDescriptorDto> MapToVoucherDescriptor(FixedList <Voucher> list)
{
return(new FixedList <VoucherDescriptorDto>(list.Select((x) => MapToVoucherDescriptor(x))));
}
private static FixedList <VoucherEntryDescriptorDto> MapToVoucherEntriesDescriptor(FixedList <VoucherEntry> entries)
{
return(new FixedList <VoucherEntryDescriptorDto>(entries.Select((x) => MapToVoucherEntryDescriptor(x))));
}
static internal FixedList <NamedEntityDto> MapToNamedEntityList(FixedList <Ledger> list)
{
return(new FixedList <NamedEntityDto>(list.Select(x => x.MapToNamedEntity())));
}
static internal FixedList <LedgerRuleDto> MapLedgersRules(FixedList <LedgerRule> list)
{
return(new FixedList <LedgerRuleDto>(list.Select(x => MapLedgerRule(x))));
}
static internal FixedList <LedgerDto> Map(FixedList <Ledger> list)
{
return(new FixedList <LedgerDto>(list.Select((x) => Map(x))));
}
static private FixedList <AccountDescriptorDto> MapToAccountDescriptors(FixedList <Account> list)
{
return(new FixedList <AccountDescriptorDto>(list.Select((x) => MapToAccountDescriptor(x))));
}
static internal FixedList <SectorDto> MapSectors(FixedList <Sector> list)
{
return(new FixedList <SectorDto>(list.Select((x) => MapSector(x))));
}
public string TokensToString()
{
return(string.Concat(Tokens.Select(t => t.Text(File.Code))));
}
static internal FixedList <StoredBalanceSetDto> Map(FixedList <StoredBalanceSet> list)
{
return(new FixedList <StoredBalanceSetDto>(list.Select(x => Map(x))));
}
static internal FixedList <CurrencyDto> MapCurrencies(FixedList <Currency> list)
{
return(new FixedList <CurrencyDto>(list.Select((x) => MapCurrency(x))));
}
static internal FixedList <SignRequest> Map(FixedList <string> source)
{
var enumerable = source.Select(uid => SignRequest.Parse(uid));
return(new FixedList <SignRequest>(enumerable));
}
static internal FixedList <EFilingRequestDto> Map(FixedList <EFilingRequest> source)
{
return(new FixedList <EFilingRequestDto>(source.Select((x) => Map(x))));
}
static internal FixedList <StepDto> Map(FixedList <Step> list)
{
var mappedItems = list.Select((x) => Map(x));
return(new FixedList <StepDto>(mappedItems));
}
static private FixedList <StoredBalanceDto> MapBalances(FixedList <StoredBalance> balances)
{
return(new FixedList <StoredBalanceDto>(balances.Select(x => MapBalance(x))));
}
static internal FixedList <StepDescriptorDto> MapToShortModel(FixedList <Step> list)
{
var mappedItems = list.Select((x) => MapToShortModel(x));
return(new FixedList <StepDescriptorDto>(mappedItems));
}
static internal FixedList <AccountsChartMasterDataDto> Map(FixedList <AccountsChartMasterData> list)
{
return(new FixedList <AccountsChartMasterDataDto>(list.Select((x) => Map(x))));
}
private static FixedList <Parameter> BuildParameters(FixedList <ParameterSyntax> parameters)
{
return(parameters.Select(BuildParameter).ToFixedList());
}
