package com.sun.ebank.ejb.tx;
import java.sql.*;
import javax.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.*;
import java.rmi.RemoteException;
import com.sun.ebank.ejb.account.AccountHome;
import com.sun.ebank.ejb.account.Account;
import com.sun.ebank.ejb.exception.TxNotFoundException;
import com.sun.ebank.ejb.exception.AccountNotFoundException;
import com.sun.ebank.ejb.exception.InsufficientFundsException;
import com.sun.ebank.ejb.exception.InsufficientCreditException;
import com.sun.ebank.ejb.exception.IllegalAccountTypeException;
import com.sun.ebank.util.Debug;
import com.sun.ebank.util.TxDetails;
import com.sun.ebank.util.DBHelper;
import com.sun.ebank.util.EJBGetter;
import com.sun.ebank.util.CodedNames;
import com.sun.ebank.util.DomainUtil;
public class TxControllerBean implements SessionBean {
private TxHome txHome;
private AccountHome accountHome;
private Connection con;
private SessionContext context;
public ArrayList getTxsOfAccount(java.util.Date startDate,
java.util.Date endDate, String accountId)
throws RemoteException {
Debug.print("TxControllerBean getTxsOfAccount");
Collection txIds;
ArrayList txList = new ArrayList();
if (startDate == null)
throw new IllegalArgumentException("null startDate");
if (endDate == null)
throw new IllegalArgumentException("null endDate");
if (accountId == null)
throw new IllegalArgumentException("null accountId");
try {
txIds = txHome.findByAccountId(startDate, endDate, accountId);
} catch (Exception ex) {
return txList;
}
Iterator i = txIds.iterator();
while (i.hasNext()) {
Tx tx = (Tx)i.next();
TxDetails txDetail = tx.getDetails();
txList.add(txDetail);
}
return txList;
} // getTxsOfAccount
public TxDetails getDetails(String txId) throws TxNotFoundException {
Debug.print("TxControllerBean getDetails");
if (txId == null)
throw new IllegalArgumentException("null txId");
try {
Tx tx = txHome.findByPrimaryKey(txId);
return tx.getDetails();
} catch (Exception ex) {
throw new TxNotFoundException(txId);
}
} // getDetails
public void withdraw(double amount, String description,
String accountId) throws IllegalArgumentException,
AccountNotFoundException, IllegalAccountTypeException,
InsufficientFundsException, RemoteException {
Debug.print("TxControllerBean withdraw");
Account account = checkAccountArgs(amount, description, accountId);
String type = account.getType();
if (DomainUtil.isCreditAccount(type))
throw new IllegalAccountTypeException(type);
double newBalance = account.getBalance() - amount;
if (newBalance < 0.0)
throw new InsufficientFundsException();
executeTx(-1 * amount, description, accountId, newBalance, account);
} // withdraw
public void deposit(double amount, String description,
String accountId) throws IllegalArgumentException,
AccountNotFoundException, IllegalAccountTypeException,
RemoteException {
Debug.print("TxControllerBean deposit");
Account account = checkAccountArgs(amount, description, accountId);
String type = account.getType();
if (DomainUtil.isCreditAccount(type))
throw new IllegalAccountTypeException(type);
double newBalance = account.getBalance() + amount;
executeTx(amount, description, accountId, newBalance, account);
} // deposit
public void makeCharge(double amount, String description,
String accountId) throws IllegalArgumentException,
AccountNotFoundException, IllegalAccountTypeException,
InsufficientCreditException, RemoteException {
Debug.print("TxControllerBean charge");
Account account = checkAccountArgs(amount, description, accountId);
String type = account.getType();
if (DomainUtil.isCreditAccount(type) == false)
throw new IllegalAccountTypeException(type);
double newBalance = account.getBalance() + amount;
if (newBalance > account.getCreditLine())
throw new InsufficientCreditException();
executeTx(amount, description, accountId, newBalance, account);
} // charge
public void makePayment(double amount, String description,
String accountId) throws IllegalArgumentException,
AccountNotFoundException, IllegalAccountTypeException,
RemoteException {
Debug.print("TxControllerBean makePayment");
Account account = checkAccountArgs(amount, description, accountId);
String type = account.getType();
if (DomainUtil.isCreditAccount(type) == false)
throw new IllegalAccountTypeException(type);
double newBalance = account.getBalance() - amount;
executeTx(-1 * amount, description, accountId, newBalance, account);
} // makePayment
public void transferFunds(double amount, String description,
String fromAccountId, String toAccountId) throws
RemoteException, IllegalArgumentException,
AccountNotFoundException, InsufficientFundsException,
InsufficientCreditException {
Account fromAccount = checkAccountArgs(amount, description,
fromAccountId);
Account toAccount = checkAccountArgs(amount, description,
toAccountId);
String fromType = fromAccount.getType();
double fromBalance = fromAccount.getBalance();
if (DomainUtil.isCreditAccount(fromType)) {
double fromNewBalance = fromBalance + amount;
if (fromNewBalance > fromAccount.getCreditLine())
throw new InsufficientCreditException();
executeTx(amount, description, fromAccountId,
fromNewBalance, fromAccount);
} else {
double fromNewBalance = fromBalance - amount;
if (fromNewBalance < 0.0)
throw new InsufficientFundsException();
executeTx(-1 * amount, description, fromAccountId,
fromNewBalance, fromAccount);
}
String toType = toAccount.getType();
double toBalance = toAccount.getBalance();
if (DomainUtil.isCreditAccount(toType)) {
double toNewBalance = toBalance - amount;
executeTx(-1 * amount, description, toAccountId,
toNewBalance, toAccount);
} else {
double toNewBalance = toBalance + amount;
executeTx(amount, description, toAccountId,
toNewBalance, toAccount);
}
} // transferFunds
// private methods
private void executeTx(double amount, String description,
String accountId, double newBalance, Account account) {
Debug.print("TxControllerBean executeTx");
try {
makeConnection();
String txId = DBHelper.getNextTxId(con);
account.setBalance(newBalance);
Tx tx = txHome.create(txId, accountId, new java.util.Date(),
amount, newBalance, description);
} catch (Exception ex) {
throw new EJBException("executeTx: " + ex.getMessage());
} finally {
releaseConnection();
}
} // executeTx
private Account checkAccountArgs(double amount, String description,
String accountId) throws IllegalArgumentException,
AccountNotFoundException {
Account account = null;
if (description == null)
throw new IllegalArgumentException("null description");
if (accountId == null)
throw new IllegalArgumentException("null accountId" );
if (amount <= 0)
throw new IllegalArgumentException("amount <= 0");
try {
account = accountHome.findByPrimaryKey(accountId);
} catch (Exception ex) {
throw new AccountNotFoundException(accountId);
}
return account;
} // checkAccountArgs
// ejb methods
public void ejbCreate() {
Debug.print("TxControllerBean ejbCreate");
try {
txHome = EJBGetter.getTxHome();
accountHome = EJBGetter.getAccountHome();
} catch (Exception ex) {
throw new EJBException("ejbCreate: " +
ex.getMessage());
}
} // ejbCreate
public void setSessionContext(SessionContext context) {
this.context = context;
}
public TxControllerBean() {}
public void ejbRemove() {}
public void ejbActivate() {}
public void ejbPassivate() {}
/*********************** Database Routines *************************/
private void makeConnection() {
Debug.print("TxControllerBean makeConnection");
try {
InitialContext ic = new InitialContext();
DataSource ds = (DataSource) ic.lookup(CodedNames.BANK_DATABASE);
con = ds.getConnection();
} catch (Exception ex) {
throw new EJBException("Unable to connect to database. " +
ex.getMessage());
}
} // makeConnection
private void releaseConnection() {
Debug.print("TxControllerBean releaseConnection");
try {
con.close();
} catch (SQLException ex) {
throw new EJBException("releaseConnection: " + ex.getMessage());
}
} // releaseConnection
} // TxControllerBean