finance-analyzer/src/main/java/de/arminwolf/financeanalyzer/service/ReportService.java

package de.arminwolf.financeanalyzer.service;

import de.arminwolf.financeanalyzer.conf.Configuration;
import de.arminwolf.financeanalyzer.dao.ReportDAO;
import de.arminwolf.financeanalyzer.dao.TableDataDAO;
import de.arminwolf.financeanalyzer.dao.TransactionDAO;
import de.arminwolf.financeanalyzer.service.usecases.CashFlowService;
import de.arminwolf.financeanalyzer.service.usecases.IncomeService;
import de.arminwolf.financeanalyzer.service.usecases.OtherTransactionService;
import de.arminwolf.financeanalyzer.service.usecases.StandingOrderService;
import de.arminwolf.financeanalyzer.util.DateUtil;
import de.arminwolf.financeanalyzer.util.TransactionDateStringComparator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;

import java.time.LocalDate;
import java.time.YearMonth;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import static de.arminwolf.financeanalyzer.util.Constants.AUSGABEN;
import static de.arminwolf.financeanalyzer.util.Constants.BEGUENSTIGTER;
import static de.arminwolf.financeanalyzer.util.Constants.BETRAG;
import static de.arminwolf.financeanalyzer.util.Constants.DATUM;
import static de.arminwolf.financeanalyzer.util.Constants.EINNAHMEN;
import static de.arminwolf.financeanalyzer.util.Constants.TURNUS;
import static de.arminwolf.financeanalyzer.util.Constants.VERWENDUNGSZWECK;

@Service
public class ReportService {


	public static final String EUR = " EUR";
	@Autowired
	private IncomeService   incomeService;
	@Autowired
	private CashFlowService cashFlowService;

	@Autowired
	private StandingOrderService standingOrderService;

	@Autowired
	private OtherTransactionService otherTransactionService;

	@Autowired
	private CacheService cacheService;

	private ReportDAO report;


	public ReportDAO createReport(final TransactionDAO[] response, String month, String iban, final Model model) {
		this.report = new ReportDAO();
		System.out.println("LocalDate :  " + DateUtil.parseMonth(month));
		int numberOfMonths = DateUtil.monthsBetween(DateUtil.parseMonth(month), LocalDate.now());
		final List<TransactionDAO> filteredIncomeTransactions  = getFilteredIncomeTransactions(response, numberOfMonths, iban);
		final List<TransactionDAO> filteredExpenseTransactions = getFilteredExpenseTransactions(response, numberOfMonths, iban);

		// Verarbeiten Sie hier die Antwort
		((Configuration) cacheService.get("configuration")).getBankAccounts().stream()
				.filter(bankAccount -> bankAccount.getIban().equals(iban)).findFirst()
				.ifPresent(bankAccount -> {
					model.addAttribute("accountName", bankAccount.getBankAccountName());
					model.addAttribute("iban", iban);
				});

		// Daueraufträge
		standingOrderService.setStandingOrder(report, filteredExpenseTransactions);

		// Sonstige Transaktionen
		otherTransactionService.setOtherTransaction(report, filteredExpenseTransactions);

		// Cashflow
		cashFlowService.setCashFlowChart(report, filteredIncomeTransactions, filteredExpenseTransactions);

		// Einkommen
		incomeService.setIncome(report, filteredIncomeTransactions);


		LocalDate       localDate = LocalDate.now().minusMonths(numberOfMonths);
		final LocalDate start     = DateUtil.getFirstDayOfMonth(localDate);
		final LocalDate end       = DateUtil.getLastDayOfMonth(localDate);

		model.addAttribute("date", String.format("%s - %s", DateUtil.format(start), DateUtil.format(end)));
		model.addAttribute("numberOfMonths", numberOfMonths);


		model.addAttribute("cashFlow", getCashFlowData());
		model.addAttribute("income", getIncomeData());
		model.addAttribute("standingOrders", getStandingOrdersData());
		model.addAttribute("notStandingOrders", getNotStandingOrdersData());

		model.addAttribute("incomeExpenseColumnReport", report.getCashFlowChart());
		model.addAttribute("accountBalanceLineChart", report.getAccountBalanceLineChart());
		model.addAttribute("transactionCategories", report.getTransactionCategoriesBubbleChart());

		return report;
	}


	private TableDataDAO getCashFlowData() {
		TableDataDAO cashFlowData = TableDataDAO.TableDataFactory.createTableDataDTO();
		cashFlowData.setHeaders(Arrays.asList("Einnahmen", "Verträge", "Ausgaben (ohne Veträge)", "Ausgaben insgesammt", "Differenz"));
		cashFlowData.setRows(List.of(
				Arrays.asList(
						String.valueOf(report.getIncome()).concat(EUR),
						String.valueOf(report.getStandingOrdersAmount()).concat(EUR),
						String.valueOf(report.getNotStandingOrdersAmount()).concat(EUR),
						String.valueOf(report.getTotalExpense()).concat(EUR),
						String.valueOf(report.getDiff()).concat(EUR)))
		);
		return cashFlowData;
	}


	private List<TransactionDAO> getFilteredIncomeTransactions(final TransactionDAO[] response, final int numberOfMonths, final String iban) {
		return getFilteredTransactions(response, EINNAHMEN, numberOfMonths, iban);
	}


	private List<TransactionDAO> getFilteredExpenseTransactions(final TransactionDAO[] response, final int numberOfMonths, final String iban) {
		return getFilteredTransactions(response, AUSGABEN, numberOfMonths, iban);
	}


	private List<TransactionDAO> getFilteredTransactions(final TransactionDAO[] response, final String type, int numberOfMonths, String iban) {
		final LocalDate localDate = LocalDate.now().minusMonths(numberOfMonths);
		final LocalDate start     = LocalDate.of(localDate.getYear(), localDate.getMonth(), 1);
		final LocalDate end       = YearMonth.of(localDate.getYear(), localDate.getMonth()).atEndOfMonth();

		return Arrays.stream(response)
				.filter(t -> DateUtil.isBetween(t.getBuchungstag(), start, end))
				.filter(t -> t.getReferenzkonto().equals(iban))
				.filter(e -> e.getAnalyseBetrag().equals(type))
				.sorted(new TransactionDateStringComparator())
				.collect(Collectors.toList());
	}



	private TableDataDAO getIncomeData() {
		TableDataDAO incomeData = TableDataDAO.TableDataFactory.createTableDataDTO();
		incomeData.setHeaders(Arrays.asList(BETRAG, DATUM, BEGUENSTIGTER, VERWENDUNGSZWECK));
		incomeData.setRows(report.getIncomeList().stream()
				.map(income -> Arrays.asList(
						income.getAmount(),
						income.getDate(),
						income.getRecipient(),
						income.getPurpose())).toList());
		return incomeData;
	}


	private TableDataDAO getNotStandingOrdersData() {
		TableDataDAO notStandingOrders = TableDataDAO.TableDataFactory.createTableDataDTO();
		notStandingOrders.setHeaders(Arrays.asList(BETRAG, DATUM, TURNUS, BEGUENSTIGTER, VERWENDUNGSZWECK));
		notStandingOrders.setRows(report.getSortedNotStandingOrders().stream()
				.map(income -> Arrays.asList(
						income.getAmount(),
						income.getDate(),
						income.getContractTurnaround(),
						income.getRecipient(),
						income.getPurpose())).toList());
		return notStandingOrders;
	}


	private TableDataDAO getStandingOrdersData() {
		TableDataDAO standingOrders = TableDataDAO.TableDataFactory.createTableDataDTO();
		standingOrders.setHeaders(Arrays.asList(BETRAG, DATUM, TURNUS, BEGUENSTIGTER, VERWENDUNGSZWECK));
		standingOrders.setRows(report.getSortedStandingOrders().stream()
				.map(income -> Arrays.asList(
						income.getAmount(),
						income.getDate(),
						income.getContractTurnaround(),
						income.getRecipient(),
						income.getPurpose())).toList());
		return standingOrders;
	}
}