Beispiel #1
0
        public SingleObjectModel SearchAccounts([FromUri] string accountsChartUID,
                                                [FromBody] AccountsSearchCommand searchCommand)
        {
            base.RequireBody(searchCommand);

            using (var usecases = AccountsChartUseCases.UseCaseInteractor()) {
                AccountsChartDto accountsChart = usecases.SearchAccounts(accountsChartUID, searchCommand);

                return(new SingleObjectModel(base.Request, accountsChart));
            }
        }
        public void Should_Search_Accounts()
        {
            var searchCommand = new AccountsSearchCommand {
                Date        = new DateTime(2005, 10, 23),
                FromAccount = "1000",
                ToAccount   = "5000",
                Keywords    = "Circulante",
            };

            AccountsChartDto accountsChart = _usecases.SearchAccounts(TestingConstants.ACCOUNTS_CHART_UID,
                                                                      searchCommand);

            Assert.Equal(TestingConstants.ACCOUNTS_CHART_UID, accountsChart.UID);
        }
        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);
        }
Beispiel #4
0
        public SingleObjectModel GetAccountsInExcelFile([FromUri] string accountsChartUID,
                                                        [FromBody] AccountsSearchCommand searchCommand)
        {
            base.RequireBody(searchCommand);

            using (var usecases = AccountsChartUseCases.UseCaseInteractor()) {
                AccountsChartDto accountsChart = usecases.SearchAccounts(accountsChartUID, searchCommand);

                var excelExporter = new ExcelExporter();

                ExcelFileDto excelFileDto = excelExporter.Export(accountsChart, searchCommand);

                return(new SingleObjectModel(base.Request, excelFileDto));
            }
        }
Beispiel #5
0
        public ExcelFileDto Export(AccountsChartDto accountsChart,
                                   AccountsSearchCommand searchCommand)
        {
            Assertion.AssertObject(accountsChart, "accountsChart");
            Assertion.AssertObject(searchCommand, "searchCommand");

            var templateUID = $"AccountsChartTemplate";

            var templateConfig = ExcelTemplateConfig.Parse(templateUID);

            var creator = new AccountsChartExcelFileCreator(templateConfig);

            ExcelFile excelFile = creator.CreateExcelFile(accountsChart);

            return(ExcelFileMapper.Map(excelFile));
        }
Beispiel #6
0
        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));
            }
        }