ConfirmationLetterGenerator.java

package com.example.confirmationletter;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.webflow.execution.RequestContext;

import com.example.dao.CurrencyDao;
import com.example.domain.AmountAndRecordsPerBank;
import com.example.domain.BatchTotal;
import com.example.domain.Client;
import com.example.domain.ConfirmationLetter;
import com.example.domain.Currency;
import com.example.domain.HashBatchRecordsBalance;
import com.example.domain.Record;
import com.example.record.command.FileUploadCommand;
import com.example.record.domain.TempRecord;
import com.example.record.parser.FileExtension;
import com.example.record.service.impl.Constants;

public class ConfirmationLetterGenerator {

	@SuppressWarnings("unused")
	 private static Log logger = LogFactory.getLog(ConfirmationLetterGenerator.class);
	private static final String COLLECTIVE = "collectief";

	private String crediting;
	private String debiting;
	private String debit;
	private String credit;
	private String type;
	private LetterSelector letterSelector;
	private CurrencyDao currencyDao;

	public CurrencyDao getCurrencyDao() {
		return currencyDao;
	}

	public void setCurrencyDao(CurrencyDao currencyDao) {
		this.currencyDao = currencyDao;
	}

	public OurOwnByteArrayOutputStream letter(RequestContext context,
			FileUploadCommand fileUploadCommand, Client client,
			HashBatchRecordsBalance hashBatchRecordsBalance, String branchName,
			List<AmountAndRecordsPerBank> bankMap,
			List<com.example.record.domain.FaultRecord> faultyRecords,
			FileExtension extension, List<Record> records,
			List<TempRecord> faultyAccountNumberRecordList,
			List<TempRecord> sansDuplicateFaultRecordsList
	// ,
	// List<BigDecimal> retrievedAmountFL,
	// List<BigDecimal> retrievedAmountEUR,
	// List<BigDecimal> retrievedAmountUSD
	) {

		ConfirmationLetter letter = new ConfirmationLetter();
		letter.setCurrency(records.get(0).getCurrency());
		letter.setExtension(extension);

		letter.setHashTotalCredit(hashBatchRecordsBalance.getHashTotalCredit()
				.toString());
		letter.setHashTotalDebit(hashBatchRecordsBalance.getHashTotalDebit()
				.toString());

		letter.setBatchTotalDebit(debitBatchTotal(
				hashBatchRecordsBalance.getBatchTotals(), client).toString());
		letter.setBatchTotalCredit(creditBatchTotal(
				hashBatchRecordsBalance.getBatchTotals(), client).toString());

		letter.setTotalProcessedRecords(hashBatchRecordsBalance
				.getRecordsTotal().toString());
		if (fileUploadCommand.getFee().equalsIgnoreCase(Constants.YES)) {
			letter.setTransactionCost(hashBatchRecordsBalance.getTotalFee()
					.toString());
		} else
			letter.setTransactionCost("");
		letter.setTransferType(hashBatchRecordsBalance.getCollectionType());
		// // logger.debug("letter method, bankMap: "+bankMap.size());
		letter.setBanks(bankMap);

		// uncommented this line
		letter.setCreditingErrors(faultyRecords);
		letter.setClient(client);
		letter.setBranchName(branchName);
		Map<String, BigDecimal> retrievedAmounts = new HashMap<String, BigDecimal>();
		retrievedAmounts = calculateRetrieveAmounts(records, faultyRecords,
				client, extension, faultyAccountNumberRecordList,
				sansDuplicateFaultRecordsList);
		letter.setRetrievedAmountEur(retrievedAmounts
				.get(Constants.CURRENCY_EURO));
		letter.setRetrievedAmountFL(retrievedAmounts
				.get(Constants.CURRENCY_FL));
		letter.setRetrievedAmountUsd(retrievedAmounts
				.get(Constants.CURRENCY_FL));
//		System.out.println("TRACING AMOUNT ["+letter.getRetrievedAmountFL()+"]");
		// letter.setRetrievedAmountFLDBF(retrievedAmounts.get("FLDBF"));
		// letter.setRetrievedAmountUSDDBF(retrievedAmounts.get("USDDBF"));
		// letter.setRetrievedAmountEURDBF(retrievedAmounts.get("EURDBF"));
		letter.setTotalRetrievedRecords(fileUploadCommand.getTotalRecords());
		OurOwnByteArrayOutputStream arrayOutputStream = letterSelector
				.generateLetter(client.getCreditDebit(), letter);

		context.getConversationScope().asMap().put("dsbByteArrayOutputStream",
				arrayOutputStream);

		return arrayOutputStream;
	}

	// Calculate sum amount from faultyAccountnumber list

	private Map<String, BigDecimal> calculateAmountsFaultyAccountNumber(
			List<TempRecord> faultyAccountNumberRecordList, Client client) {
		Map<String, BigDecimal> retrievedAmountsFaultyAccountNumber = new HashMap<String, BigDecimal>();

		BigDecimal faultyAccRecordAmountCreditFL = new BigDecimal(0);
		BigDecimal faultyAccRecordAmountCreditUSD = new BigDecimal(0);
		BigDecimal faultyAccRecordAmountCreditEUR = new BigDecimal(0);

		BigDecimal faultyAccRecordAmountDebitFL = new BigDecimal(0);
		BigDecimal faultyAccRecordAmountDebitUSD = new BigDecimal(0);
		BigDecimal faultyAccRecordAmountDebitEUR = new BigDecimal(0);

		for (TempRecord faultyAccountNumberRecord : faultyAccountNumberRecordList) {
			// // logger.debug("faultyAccountNumberRecord: "+
			// faultyAccountNumberRecord);
			// FL
			if (StringUtils.isBlank(faultyAccountNumberRecord.getSign())) {
				faultyAccountNumberRecord.setSign(client.getCreditDebit());
			}

			if (faultyAccountNumberRecord.getCurrencycode() == null) {
				String currencyId = currencyDao.retrieveCurrencyDefault(client
						.getProfile());
				Currency currency = currencyDao
						.retrieveCurrencyOnId(new Integer(currencyId));
				faultyAccountNumberRecord.setCurrencycode(currency.getCode()
						.toString());
			}

			if (faultyAccountNumberRecord.getCurrencycode().equals(
					Constants.FL_CURRENCY_CODE)
					|| faultyAccountNumberRecord.getCurrencycode().equals(
							Constants.FL_CURRENCY_CODE_FOR_WEIRD_BANK)) {

				if (faultyAccountNumberRecord.getSign().equalsIgnoreCase(
						Constants.DEBIT)) {
					faultyAccRecordAmountDebitFL = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountDebitFL);
				} else {
					faultyAccRecordAmountCreditFL = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountCreditFL);
				}
			}
			if (faultyAccountNumberRecord.getCurrencycode().equals(
					Constants.USD_CURRENCY_CODE)) {
				if (faultyAccountNumberRecord.getSign().equalsIgnoreCase(
						Constants.DEBIT)) {
					faultyAccRecordAmountDebitUSD = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountDebitUSD);
				} else {
					faultyAccRecordAmountCreditUSD = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountCreditUSD);
				}
			}
			if (faultyAccountNumberRecord.getCurrencycode().equals(
					Constants.EUR_CURRENCY_CODE)) {
				if (faultyAccountNumberRecord.getSign().equalsIgnoreCase(
						Constants.DEBIT)) {
					faultyAccRecordAmountDebitEUR = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountDebitEUR);
				} else {
					faultyAccRecordAmountCreditEUR = new BigDecimal(
							faultyAccountNumberRecord.getAmount())
							.add(faultyAccRecordAmountCreditEUR);
				}
			}

			retrievedAmountsFaultyAccountNumber.put("FaultyAccDebitFL",
					faultyAccRecordAmountDebitFL);
			retrievedAmountsFaultyAccountNumber.put("FaultyAccDebitUSD",
					faultyAccRecordAmountDebitUSD);
			retrievedAmountsFaultyAccountNumber.put("FaultyAccDebitEUR",
					faultyAccRecordAmountDebitEUR);

			retrievedAmountsFaultyAccountNumber.put("FaultyAccCreditFL",
					faultyAccRecordAmountCreditFL);
			retrievedAmountsFaultyAccountNumber.put("FaultyAccCreditUSD",
					faultyAccRecordAmountCreditUSD);
			retrievedAmountsFaultyAccountNumber.put("FaultyAccCreditEUR",
					faultyAccRecordAmountCreditEUR);

		}
		return retrievedAmountsFaultyAccountNumber;
	}

	private Map<String, BigDecimal> calculateRetrieveAmounts(
			List<Record> records,
			List<com.example.record.domain.FaultRecord> faultyRecords,
			Client client, FileExtension extension,
			List<TempRecord> faultyAccountNumberRecordList,
			List<TempRecord> sansDuplicateFaultRecordsList) {

		Map<String, BigDecimal> retrievedAmounts = new HashMap<String, BigDecimal>();

		BigDecimal recordAmountFL = new BigDecimal(0);
		BigDecimal recordAmountUSD = new BigDecimal(0);
		BigDecimal recordAmountEUR = new BigDecimal(0);

		BigDecimal recordAmountDebitFL = new BigDecimal(0);
		BigDecimal recordAmountDebitEUR = new BigDecimal(0);
		BigDecimal recordAmountDebitUSD = new BigDecimal(0);

		BigDecimal recordAmountCreditFL = new BigDecimal(0);
		BigDecimal recordAmountCreditEUR = new BigDecimal(0);
		BigDecimal recordAmountCreditUSD = new BigDecimal(0);

		BigDecimal amountSansDebitFL = new BigDecimal(0);
		BigDecimal amountSansDebitUSD = new BigDecimal(0);
		BigDecimal amountSansDebitEUR = new BigDecimal(0);

		BigDecimal amountSansCreditFL = new BigDecimal(0);
		BigDecimal amountSansCreditUSD = new BigDecimal(0);
		BigDecimal amountSansCreditEUR = new BigDecimal(0);

		BigDecimal totalDebitFL = new BigDecimal(0);
		BigDecimal totalDebitUSD = new BigDecimal(0);
		BigDecimal totalDebitEUR = new BigDecimal(0);

		BigDecimal totalCreditFL = new BigDecimal(0);
		BigDecimal totalCreditUSD = new BigDecimal(0);
		BigDecimal totalCreditEUR = new BigDecimal(0);

		if (client.getCounterTransfer().equalsIgnoreCase(Constants.TRUE)) {
			for (Record record : records) {
				if (record.getFeeRecord() != 1) {
					if ((record.getCurrency().getCode().equals(
							Constants.FL_CURRENCY_CODE) || record
							.getCurrency().getCode().equals(
									Constants.FL_CURRENCY_CODE_FOR_WEIRD_BANK))
							&& record.getSign().equalsIgnoreCase(
									Constants.DEBIT)) {
						recordAmountFL = record.getAmount().add(
								recordAmountFL);
						// system.out.println("recordAmountFL: ["+ recordAmountFL + "]");

					}
					if (record.getCurrency().getCode().equals(
							Constants.EUR_CURRENCY_CODE)
							&& record.getSign().equalsIgnoreCase(
									Constants.DEBIT)) {
						recordAmountEUR = record.getAmount().add(
								recordAmountEUR);
						// system.out.println("recordAmountEUR: ["+ recordAmountEUR + "]");

					}
					if (record.getCurrency().getCode().equals(
							Constants.USD_CURRENCY_CODE)
							&& record.getSign().equalsIgnoreCase(
									Constants.DEBIT)) {
						recordAmountUSD = record.getAmount().add(
								recordAmountUSD);
						// system.out.println("recordAmountUSD: ["+ recordAmountUSD + "]");
					}
				}
				retrievedAmounts.put(Constants.CURRENCY_EURO, recordAmountEUR);
				retrievedAmounts.put(Constants.CURRENCY_FL, recordAmountUSD);
				retrievedAmounts.put(Constants.CURRENCY_FL, recordAmountFL);
			}
		}
		// Not Balanced
		else {

			for (Record record : records) {
				logger.debug("COUNTERTRANSFER ["+record.getIsCounterTransferRecord()+"] FEERECORD ["+record.getFeeRecord()+"]");
				if (record.getIsCounterTransferRecord().compareTo(new Integer(0))==0
						&& record.getFeeRecord().compareTo(new Integer(0))==0) {
					if ((record.getCurrency().getCode().equals(
							Constants.FL_CURRENCY_CODE) || record
							.getCurrency().getCode().equals(
									Constants.FL_CURRENCY_CODE_FOR_WEIRD_BANK))) {
//						System.out.println("record to string: ["+record.toString()+"]");
						if (record.getSign().equalsIgnoreCase(Constants.DEBIT)) {
//							 System.out.println("record.getamount DEBIT = ["+ record.getAmount() + "]");
							// system.out.println("recordAmountDebitFL 1 = "+ recordAmountDebitFL);
							recordAmountDebitFL = record.getAmount().add(
									recordAmountDebitFL);
//							System.out.println("recordAmountDebitFL: ["+recordAmountDebitFL+"]");
						}
						if (record.getSign().equalsIgnoreCase(Constants.CREDIT)) {
//							 System.out.println("record.getamount CREDIT = ["+record.getAmount()+"]");
							// system.out.println("recordAmountCreditFL 1 = ["+recordAmountCreditFL+"]");

							recordAmountCreditFL = record.getAmount().add(
									recordAmountCreditFL);
//							System.out.println("recordAmountCreditFL: ["+recordAmountCreditFL+"]");
						}

						if (record.getCurrency().getCode().equals(
								Constants.EUR_CURRENCY_CODE)) {

							if (record.getSign().equalsIgnoreCase(
									Constants.DEBIT)) {
								recordAmountDebitEUR = record.getAmount().add(
										recordAmountDebitEUR);
								// system.out.println("recordAmountDebitEUR: ["+recordAmountDebitEUR+"]");
							}
							if (record.getSign().equalsIgnoreCase(
									Constants.CREDIT)) {
								recordAmountCreditEUR = record.getAmount().add(
										recordAmountCreditEUR);
								// system.out.println("recordAmountCreditEUR: ["+recordAmountCreditEUR+"]");
							}

						}

					}
				}

				if (record.getCurrency().getCode().equals(
						Constants.USD_CURRENCY_CODE)) {

					if (record.getSign().equalsIgnoreCase(Constants.DEBIT)) {
						recordAmountDebitUSD = record.getAmount().add(
								recordAmountDebitUSD);
						// system.out.println("recordAmountDebitUSD: ["+recordAmountDebitUSD+"]");
					}
					if (record.getSign().equalsIgnoreCase(Constants.CREDIT)) {
						recordAmountCreditUSD = record.getAmount().add(
								recordAmountCreditUSD);
						// system.out.println("recordAmountCreditUSD: ["+recordAmountCreditUSD+"]");
					}

				}

			}
			// Sansduplicate
			for (TempRecord sansDupRec : sansDuplicateFaultRecordsList) {
				// logger.debug("sansDupRec: "+sansDupRec);
				String currencyCode = sansDupRec.getCurrencycode();
				if (sansDupRec.getSign() == null) {
					String sign = client.getCreditDebit();
					sansDupRec.setSign(sign);
				}
				if (currencyCode == null) {
					String currencyId = currencyDao
							.retrieveCurrencyDefault(client.getProfile());
					Currency currency = currencyDao
							.retrieveCurrencyOnId(new Integer(currencyId));
					sansDupRec.setCurrencycode(currency.getCode().toString());
				} else {

					if (currencyCode.equals(Constants.FL_CURRENCY_CODE)
							|| currencyCode
									.equals(Constants.FL_CURRENCY_CODE_FOR_WEIRD_BANK)) {

						if (sansDupRec.getSign().equalsIgnoreCase(
								Constants.DEBIT)) {
							amountSansDebitFL = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansDebitFL);
						} else {
							amountSansCreditFL = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansCreditFL);
						}
					}
					if (currencyCode.equals(Constants.USD_CURRENCY_CODE)) {
						if (sansDupRec.getSign().equalsIgnoreCase(
								Constants.DEBIT)) {
							amountSansDebitUSD = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansDebitUSD);
						} else {
							amountSansCreditUSD = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansCreditUSD);
						}
					}
					if (currencyCode.equals(Constants.EUR_CURRENCY_CODE)) {
						if (sansDupRec.getSign().equalsIgnoreCase(
								Constants.DEBIT)) {
							amountSansDebitEUR = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansDebitEUR);
						} else {
							amountSansCreditEUR = new BigDecimal(sansDupRec
									.getAmount()).add(amountSansCreditEUR);
						}
					}
				}

			}

			Map<String, BigDecimal> retrievedAccountNumberAmounts = calculateAmountsFaultyAccountNumber(
					faultyAccountNumberRecordList, client);
			// logger.info("Before total debit FL");
			// logger.info("amountSansDebitFL "+amountSansDebitFL);
			if (retrievedAccountNumberAmounts.get("FaultyAccDebitFL") != null
					&& amountSansDebitFL != null) {
				// logger.info("retrievedAccountNumberAmounts.get(FaultyAccDebitFL) "+retrievedAccountNumberAmounts.get("FaultyAccDebitFL"));
				totalDebitFL = recordAmountDebitFL.add(amountSansDebitFL)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccDebitFL"));
			} else if (amountSansDebitFL != null) {
				totalDebitFL = recordAmountDebitFL.add(amountSansDebitFL);
			} else {
				totalDebitFL = recordAmountDebitFL;
			}
			// logger.info("totalDebitFL "+totalDebitFL);

			if (retrievedAccountNumberAmounts.get("FaultyAccCreditFL") != null
					&& amountSansCreditFL != null) {
				// logger.debug("retrievedAccountNumberAmounts.get(FaultyAccCreditFL):"+retrievedAccountNumberAmounts.get("FaultyAccCreditFL"));
				totalCreditFL = recordAmountCreditFL.add(amountSansCreditFL)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccCreditFL"));
			} else if (amountSansCreditFL != null) {
				totalCreditFL = recordAmountCreditFL.add(amountSansCreditFL);
			} else {
				totalCreditFL = recordAmountCreditFL;
			}
			// logger.info("totalCreditFL: "+totalCreditFL);

			if (retrievedAccountNumberAmounts.get("FaultyAccDebitUSD") != null
					&& amountSansDebitUSD != null) {
				// logger.info("retrievedAccountNumberAmounts.get(FaultyAccDebitUSD) "+retrievedAccountNumberAmounts.get("FaultyAccDebitUSD"));
				totalDebitUSD = recordAmountDebitUSD.add(amountSansDebitUSD)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccDebitUSD"));
			} else if (amountSansDebitUSD != null) {
				totalDebitUSD = recordAmountDebitUSD.add(amountSansDebitUSD);
			} else {
				totalDebitUSD = recordAmountDebitUSD;
			}
			// logger.info("totalDebitUSD "+totalDebitUSD);

			if (retrievedAccountNumberAmounts.get("FaultyAccCreditUSD") != null
					&& amountSansCreditUSD != null) {
				// logger.debug("retrievedAccountNumberAmounts.get(FaultyAccCreditUSD):"+retrievedAccountNumberAmounts.get("FaultyAccCreditUSD"));
				totalCreditUSD = recordAmountCreditUSD.add(amountSansCreditUSD)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccCreditUSD"));
			} else if (amountSansCreditUSD != null) {
				totalCreditUSD = recordAmountCreditUSD.add(amountSansCreditUSD);
			} else {
				totalCreditUSD = recordAmountCreditUSD;
			}
			// logger.info("totalCreditUSD: "+totalCreditUSD);

			if (retrievedAccountNumberAmounts.get("FaultyAccDebitEUR") != null
					&& amountSansDebitEUR != null) {
				// logger.info("retrievedAccountNumberAmounts.get(FaultyAccDebitEUR) "+retrievedAccountNumberAmounts.get("FaultyAccDebitEUR"));
				totalDebitEUR = recordAmountDebitEUR.add(amountSansDebitEUR)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccDebitEUR"));
			} else if (amountSansDebitEUR != null) {
				totalDebitEUR = recordAmountDebitEUR.add(amountSansDebitEUR);
			} else {
				totalDebitEUR = recordAmountDebitEUR;
			}
			// logger.info("totalDebitEUR "+totalDebitEUR);

			if (retrievedAccountNumberAmounts.get("FaultyAccCreditEUR") != null
					&& amountSansCreditEUR != null) {
				// logger.debug("retrievedAccountNumberAmounts.get(FaultyAccCreditEUR):"+retrievedAccountNumberAmounts.get("FaultyAccCreditEUR"));
				totalCreditEUR = recordAmountCreditEUR.add(amountSansCreditEUR)
						.subtract(
								retrievedAccountNumberAmounts
										.get("FaultyAccCreditEUR"));
			} else if (amountSansCreditEUR != null) {
				totalCreditEUR = recordAmountCreditEUR.add(amountSansCreditEUR);
			} else {
				totalCreditEUR = recordAmountCreditEUR;
			}
			// logger.info("totalCreditEUR: "+totalCreditEUR);

			recordAmountFL = totalDebitFL.subtract(totalCreditFL).abs();
			recordAmountUSD = totalDebitUSD.subtract(totalCreditUSD).abs();
			recordAmountEUR = totalDebitEUR.subtract(totalCreditEUR).abs();

			retrievedAmounts.put(Constants.CURRENCY_EURO, recordAmountEUR);
			retrievedAmounts.put(Constants.CURRENCY_FL, recordAmountUSD);
			retrievedAmounts.put(Constants.CURRENCY_FL, recordAmountFL);

		}

		return retrievedAmounts;
	}

	private BigDecimal creditBatchTotal(Map<Integer, BatchTotal> batchTotals,
			Client client) {
		Double sum = new Double(0);
		Iterator<BatchTotal> itr = batchTotals.values().iterator();
		while (itr.hasNext()) {
			BatchTotal total = itr.next();

			sum = sum + total.getCreditValue().doubleValue();
		}
		Double d = sum / new Double(client.getAmountDivider());
		return new BigDecimal(d);
	}

	private BigDecimal debitBatchTotal(Map<Integer, BatchTotal> batchTotals,
			Client client) {
		Double sum = new Double(0);
		Iterator<BatchTotal> itr = batchTotals.values().iterator();
		while (itr.hasNext()) {
			BatchTotal total = itr.next();
			sum = sum + total.getCreditCounterValueForDebit().doubleValue();
		}
		Double d = sum / new Double(client.getAmountDivider());
		return new BigDecimal(d);
	}

	private List<AmountAndRecordsPerBank> amountAndRecords(
			List<Record> records, String transactionType) {
		List<AmountAndRecordsPerBank> list = new ArrayList<AmountAndRecordsPerBank>();
		String typeOfTransaction = transactionType.equalsIgnoreCase(crediting) ? crediting
				: debiting;
		type = typeOfTransaction.equalsIgnoreCase(crediting) ? credit : debit;
		if (transactionType.equalsIgnoreCase(typeOfTransaction)) {
			for (Record record : records) {
				getAmountAndRecords(record, list, transactionType);
			}
		}
		return list;
	}

	private List<AmountAndRecordsPerBank> getAmountAndRecords(Record record,
			List<AmountAndRecordsPerBank> list, String transactionType) {
		Map<String, String> map = new HashMap<String, String>();
		if (record.getFeeRecord().compareTo(0) == 0
				&& !map.containsKey(record.getBeneficiaryName())) {

			if (transactionType.equalsIgnoreCase(Constants.CREDITING)) {

				if (record.getBeneficiaryName() != null
						&& !record.getBeneficiaryName().equalsIgnoreCase(
								Constants.RBTT_BANK_ALTERNATE)) {
					Boolean newList = true;
					if (list.size() == 0
							&& record.getSign().equalsIgnoreCase(type)) {
						// logger.info("bank gegevens: "+record.getSign()+" : "+record.getBank().getName()+" : "+record.getBeneficiaryName());
						AmountAndRecordsPerBank aARPB = new AmountAndRecordsPerBank();
						aARPB.setBankName(record.getBank().getName());
						aARPB.setTotalRecord(1);
						aARPB.setAmount(record.getAmount());
						aARPB.setCurrencyType(record.getCurrency()
								.getCurrencyType());
						aARPB.setAccountNumber(record
								.getBeneficiaryAccountNumber());
						list.add(aARPB);
						newList = false;
					}
					if (newList && record.getSign().equalsIgnoreCase(type)) {
						// logger.info("bank gegevens: "+record.getSign()+" : "+record.getBank().getName()+" : "+record.getBeneficiaryName());
						Boolean newRecord = true;
						for (AmountAndRecordsPerBank object : list) {
							if (object.getBankName().equalsIgnoreCase(
									record.getBank().getName())
									&& object.getCurrencyType()
											.equalsIgnoreCase(
													record.getCurrency()
															.getCurrencyType())) {
								object.setAmount(object.getAmount().add(
										record.getAmount()));
								object
										.setTotalRecord(object.getTotalRecord() + 1);
								newRecord = false;
							}
						}
						if (newRecord) {
							AmountAndRecordsPerBank aARPB = new AmountAndRecordsPerBank();
							aARPB.setBankName(record.getBank().getName());
							aARPB.setTotalRecord(1);
							aARPB.setAmount(record.getAmount());
							aARPB.setCurrencyType(record.getCurrency()
									.getCurrencyType());
							aARPB.setAccountNumber(record
									.getBeneficiaryAccountNumber());
							list.add(aARPB);
						}
					}
				}
			}

			// del begin
			if (transactionType.equalsIgnoreCase(Constants.DEBITING)) {

				if (record.getBeneficiaryName() == null) {
					Boolean newList = true;
					if (list.size() == 0
							&& record.getSign().equalsIgnoreCase(type)) {
						// logger.info("bank gegevens: "+record.getSign()+" : "+record.getBank().getName()+" : "+record.getBeneficiaryName());
						AmountAndRecordsPerBank aARPB = new AmountAndRecordsPerBank();
						aARPB.setBankName(record.getBank().getName());
						aARPB.setTotalRecord(1);
						aARPB.setAmount(record.getAmount());
						aARPB.setCurrencyType(record.getCurrency()
								.getCurrencyType());
						aARPB.setAccountNumber(record
								.getBeneficiaryAccountNumber());
						list.add(aARPB);
						newList = false;
					}
					if (newList && record.getSign().equalsIgnoreCase(type)) {
						// logger.info("bank gegevens: "+record.getSign()+" : "+record.getBank().getName()+" : "+record.getBeneficiaryName());
						Boolean newRecord = true;
						for (AmountAndRecordsPerBank object : list) {
							if (object.getBankName().equalsIgnoreCase(
									record.getBank().getName())
									&& object.getCurrencyType()
											.equalsIgnoreCase(
													record.getCurrency()
															.getCurrencyType())) {
								object.setAmount(object.getAmount().add(
										record.getAmount()));
								object
										.setTotalRecord(object.getTotalRecord() + 1);
								newRecord = false;
							}
						}
						if (newRecord) {
							AmountAndRecordsPerBank aARPB = new AmountAndRecordsPerBank();
							aARPB.setBankName(record.getBank().getName());
							aARPB.setTotalRecord(1);
							aARPB.setAmount(record.getAmount());
							aARPB.setCurrencyType(record.getCurrency()
									.getCurrencyType());
							aARPB.setAccountNumber(record
									.getBeneficiaryAccountNumber());
							list.add(aARPB);
						}
					}
				}
			}
			// del end
		}
		return list;
	}

	/*
	 *
	 * Getters and setters
	 */

	public void setCrediting(String crediting) {
		this.crediting = crediting;
	}

	public void setDebiting(String debiting) {
		this.debiting = debiting;
	}

	public void setDebit(String debit) {
		this.debit = debit;
	}

	public void setCredit(String credit) {
		this.credit = credit;
	}

	public void setLetterSelector(LetterSelector letterSelector) {
		this.letterSelector = letterSelector;
	}

}