static private string BuildLedgerFilter(SearchVouchersCommand command)
{
string filter = string.Empty;
if (command.LedgerUID.Length != 0)
{
var ledger = Ledger.Parse(command.LedgerUID);
filter += $"ID_MAYOR = {ledger.Id}";
return(filter);
}
if (command.AccountsChartUID.Length != 0)
{
var accountsChart = AccountsChart.Parse(command.AccountsChartUID);
if (filter.Length != 0)
{
filter += " AND ";
}
filter += $"ID_TIPO_CUENTAS_STD = {accountsChart.Id}";
}
return(filter);
}
static internal AccountsChartDto Map(AccountsChart accountsChart)
{
return(new AccountsChartDto {
UID = accountsChart.UID,
Name = accountsChart.Name,
Accounts = MapToAccountDescriptors(accountsChart.Accounts)
});
}
public FixedList <AccountsChartMasterDataDto> GetAccountsChartsMasterData()
{
FixedList <AccountsChart> accountsChartsList = AccountsChart.GetList();
var masterDataList = new FixedList <AccountsChartMasterData>(accountsChartsList.Select(x => x.MasterData));
return(AccountsChartMasterDataMapper.Map(masterDataList));
}
public AccountsChartDto GetAccounts(string accountsChartUID)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
var accountsChart = AccountsChart.Parse(accountsChartUID);
return(AccountsChartMapper.Map(accountsChart));
}
public void Should_Get_Balances_Sets()
{
var accountsChart = AccountsChart.Parse(TestingConstants.AccountCatalogueId);
FixedList <StoredBalanceSetDto> storedBalanceSetsList = _usecases.BalanceSetsList(accountsChart.UID);
Assert.NotEmpty(storedBalanceSetsList);
}
public void Should_Search_An_Account_In_An_AccountsChart()
{
var chart = AccountsChart.Parse(TestingConstants.ACCOUNTS_CHART_UID);
Account account = chart.GetAccount(TestingConstants.ACCOUNT_NUMBER);
Assert.Equal(TestingConstants.ACCOUNT_NUMBER, account.Number);
Assert.Equal(TestingConstants.ACCOUNT_NAME, account.Name);
}
public AccountsChartDto GetAccountsInADate(string accountsChartUID, DateTime date)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
var accountsChart = AccountsChart.Parse(accountsChartUID);
FixedList <Account> accounts = accountsChart.GetAccountsInADate(date);
return(AccountsChartMapper.Map(accountsChart, accounts));
}
static internal AccountsChartDto MapWithSectors(AccountsChart accountsChart,
FixedList <Account> accounts)
{
return(new AccountsChartDto {
UID = accountsChart.UID,
Name = accountsChart.Name,
WithSectors = true,
Accounts = MapToAccountDescriptorsWithSectors(accounts)
});
}
static internal StoredBalanceSet GetBestBalanceSet(AccountsChart accountsChart,
DateTime fromDate)
{
var bestBalanceSet = GetList(accountsChart).FindLast(x => x.BalancesDate <= fromDate && x.Calculated);
Assertion.AssertObject(bestBalanceSet,
$"No hay ningún un conjunto de saldos definidos para el catálogo {accountsChart.Name}.");
return(bestBalanceSet);
}
static internal EmpiriaHashTable <Account> GetAccounts(AccountsChart accountsChart)
{
var sql = "SELECT * FROM VW_COF_CUENTA_ESTANDAR_HIST " +
$"WHERE ID_TIPO_CUENTAS_STD = {accountsChart.Id} " +
$"ORDER BY NUMERO_CUENTA_ESTANDAR";
var dataOperation = DataOperation.Parse(sql);
return(DataReader.GetHashTable <Account>(dataOperation, x => x.Number));
}
public FixedList <StoredBalanceSetDto> BalanceSetsList(string accountsChartUID)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
var accountsChart = AccountsChart.Parse(accountsChartUID);
FixedList <StoredBalanceSet> list = StoredBalanceSet.GetList(accountsChart);
return(StoredBalanceSetMapper.Map(list));
}
static internal FixedList <Ledger> GetAccountChartLedgers(AccountsChart accountsChart)
{
var sql = "SELECT COF_MAYOR.* " +
$"FROM COF_MAYOR " +
$"WHERE ID_TIPO_CUENTAS_STD = {accountsChart.Id} " +
$"ORDER BY NUMERO_MAYOR";
var dataOperation = DataOperation.Parse(sql);
return(DataReader.GetFixedList <Ledger>(dataOperation));
}
static internal FixedList <Account> GetAccountHistory(AccountsChart accountsChart,
string accountNumber)
{
var sql = "SELECT * FROM VW_COF_CUENTA_ESTANDAR_HIST " +
$"WHERE ID_TIPO_CUENTAS_STD = {accountsChart.Id} " +
$"AND NUMERO_CUENTA_ESTANDAR = '{accountNumber}' " +
$"ORDER BY FECHA_INICIO";
var dataOperation = DataOperation.Parse(sql);
return(DataReader.GetFixedList <Account>(dataOperation));
}
public void Should_Parse_An_AccountsChart()
{
var chart = AccountsChart.Parse(TestingConstants.ACCOUNTS_CHART_UID);
Assert.Equal(TestingConstants.ACCOUNTS_CHART_UID, chart.UID);
Assert.NotEmpty(chart.Accounts);
chart = AccountsChart.Parse(TestingConstants.ACCOUNTS_CHART_2021_UID);
Assert.NotEmpty(chart.Accounts);
}
static internal FixedList <Account> SearchAccounts(AccountsChart accountsChart,
string filter)
{
var sql = "SELECT * FROM VW_COF_CUENTA_ESTANDAR_HIST " +
$"WHERE ID_TIPO_CUENTAS_STD = {accountsChart.Id} " +
(filter.Length != 0 ? $" AND ({filter}) " : String.Empty) +
$"ORDER BY NUMERO_CUENTA_ESTANDAR";
var dataOperation = DataOperation.Parse(sql);
return(DataReader.GetFixedList <Account>(dataOperation));
}
static internal StoredBalanceSet CreateOrGetBalanceSet(AccountsChart accountsChart,
DateTime balancesDate)
{
var existing = GetList(accountsChart).Find(x => x.BalancesDate == balancesDate.Date);
if (existing != null)
{
return(existing);
}
return(new StoredBalanceSet(accountsChart, balancesDate));
}
private StoredBalanceSet ParseBalanceSet(string accountsChartUID, string balanceSetUID)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
Assertion.AssertObject(balanceSetUID, "balanceSetUID");
var accountsChart = AccountsChart.Parse(accountsChartUID);
var balanceSet = StoredBalanceSet.Parse(balanceSetUID);
Assertion.Assert(balanceSet.AccountsChart.Equals(accountsChart),
"The requested balance set does not belong to the given accounts chart.");
return(balanceSet);
}
public void Should_Search_Many_Accounts_In_An_AccountsChart()
{
var chart = AccountsChart.Parse(TestingConstants.ACCOUNTS_CHART_UID);
var accounts = chart.Accounts;
foreach (var item in accounts)
{
var account = chart.GetAccount(item.Number);
Assert.Equal(account.Number, item.Number);
}
}
public StoredBalanceSetDto CreateOrGetBalanceSet(string accountsChartUID,
BalanceStorageCommand command)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
Assertion.AssertObject(command, "command");
var accountsChart = AccountsChart.Parse(accountsChartUID);
var storedBalanceSet = StoredBalanceSet.CreateOrGetBalanceSet(accountsChart, command.BalancesDate);
storedBalanceSet.Save();
return(StoredBalanceSetMapper.Map(storedBalanceSet));
}
public AccountDto GetAccount(string accountsChartUID, string accountUID)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
Assertion.AssertObject(accountUID, "accountUID");
var accountsChart = AccountsChart.Parse(accountsChartUID);
Account account = Account.Parse(accountUID);
Assertion.Assert(account.AccountsChart.Equals(accountsChart),
$"The account with uid {account.UID} does not belong " +
$"to accounts chart {accountsChart.Name}");
return(AccountsChartMapper.MapAccount(account));
}
public void Should_Search_An_Account_Range_In_An_AccountsChart()
{
var chart = AccountsChart.Parse(TestingConstants.ACCOUNTS_CHART_UID);
var searchCommand = new AccountsSearchCommand {
FromAccount = "1101",
ToAccount = "2699"
};
FixedList <Account> accounts = chart.Search(searchCommand.MapToFilterString());
Assert.NotNull(accounts);
Assert.DoesNotContain(accounts, x => searchCommand.FromAccount.CompareTo(x.Number) > 0);
}
public void Should_Generate_A_Balances_Set()
{
var accountsChart = AccountsChart.Parse(TestingConstants.AccountCatalogueId);
var BALANCES_DATE = new DateTime(2000, 12, 30);
var command = new BalanceStorageCommand()
{
BalancesDate = BALANCES_DATE
};
var storedBalanceSet = _usecases.CreateOrGetBalanceSet(accountsChart.UID, command);
Assert.NotNull(storedBalanceSet);
Assert.Equal(BALANCES_DATE, storedBalanceSet.BalancesDate);
}
public AccountsChartDto SearchAccounts(string accountsChartUID,
AccountsSearchCommand command)
{
Assertion.AssertObject(accountsChartUID, "accountsChartUID");
Assertion.AssertObject(command, "command");
var accountsChart = AccountsChart.Parse(accountsChartUID);
string filter = command.MapToFilterString();
FixedList <Account> accounts = accountsChart.Search(filter);
accounts = command.Restrict(accounts);
if (command.WithSectors)
{
return(AccountsChartMapper.MapWithSectors(accountsChart, accounts));
}
else
{
return(AccountsChartMapper.Map(accountsChart, accounts));
}
}
internal TrialBalanceCommandData GetTrialBalanceCommandData(TrialBalanceCommandPeriod commandPeriod)
{
var commandData = new TrialBalanceCommandData();
var accountsChart = AccountsChart.Parse(_command.AccountsChartUID);
StoredBalanceSet balanceSet = StoredBalanceSet.GetBestBalanceSet(
accountsChart, commandPeriod.FromDate);
commandData.StoredInitialBalanceSet = balanceSet;
commandData.FromDate = commandPeriod.FromDate;
commandData.ToDate = commandPeriod.ToDate;
commandData.InitialFields = GetInitialFields();
commandData.Fields = GetOutputFields();
commandData.Filters = GetFilterString();
commandData.AccountFilters = GetAccountFilterString();
commandData.InitialGrouping = GetInitialGroupingClause();
commandData.Grouping = GetGroupingClause();
commandData.Having = GetHavingClause();
commandData.Ordering = GetOrderClause();
commandData.AccountsChart = accountsChart;
return(commandData);
}
static public FixedList <StoredBalanceSet> GetList(AccountsChart accountsChart)
{
return(_list.Value.FindAll(x => x.AccountsChart.Equals(accountsChart))
.ToFixedList());
}
private StoredBalanceSet(AccountsChart accountsChart, DateTime balancesDate)
{
this.AccountsChart = accountsChart;
this.BalancesDate = balancesDate.Date;
}
public FixedList <NamedEntityDto> GetAccountsChartsList()
{
FixedList <AccountsChart> accountsChartsList = AccountsChart.GetList();
return(accountsChartsList.MapToNamedEntityList());
}
