public static void main(String args[]) {
Account myAccount = new Account();
Account yourAccount = new Account();
myAccount.setName("Barry Burd");
myAccount.setAddress("222 Cyberspace Lane");
myAccount.setBalance(24.02);
yourAccount.setName("Jane Q. Public");
yourAccount.setAddress("111 Consumer Street");
yourAccount.setBalance(55.63);
out.print(myAccount.getName());
out.print(" (");
out.print(myAccount.getAddress());
out.print(") has $");
out.print(myAccount.getBalance());
out.println();
out.print(yourAccount.getName());
out.print(" (");
out.print(yourAccount.getAddress());
out.print(") has $");
out.print(yourAccount.getBalance());
}
public ArrayList<Account> getAccountList() {
Connection connect = null;
try {
ArrayList<Account> accounts = new ArrayList<>();
connect = DBConnection.getConnection();
String sql = "SELECT * FROM account" + "ORDER BY name desc";
ResultSet result = Utility.queryOperation(connect, sql);
Account temp = new Account();
while (result.next()) {
temp.setName(result.getString("name"));
temp.setEmail(result.getString("email"));
temp.setSecondaryEmail(result.getString("secondaryEmail"));
temp.setTypeAccount(result.getString("typeAccount"));
temp.setPassword(result.getString("password"));
temp.setAdmin(result.getBoolean("isAdministrator"));
accounts.add(temp);
}
return accounts;
} catch (SQLException ex) {
Logger.getLogger(AccountManager.class.getName()).log(Level.SEVERE, null, ex);
} finally {
DBConnection.releaseConnection(connect);
}
return null;
}
@Test
@Transactional
public void updateAccount() {
Query query = entityManager.createQuery("from Account a where a.id=:id").setParameter("id", 1L);
Account a = (Account) query.getSingleResult();
a.setName("foo");
}
public ArrayList<Account> searchUser(String search, String type) throws SQLException {
Connection connect = null;
ArrayList<Account> accounts;
String sql =
"SELECT * from account WHERE "
+ "name LIKE '%"
+ search
+ "%'"
+ "AND typeAccount = '"
+ type
+ "'";
String sql2 = "SELECT * from account WHERE " + "typeAccount ='" + type + "'";
try {
connect = DBConnection.getConnection();
accounts = new ArrayList<>();
if (search.isEmpty()) {
ResultSet result = Utility.queryOperation(connect, sql2);
Account temp = new Account();
while (result.next()) {
temp.setName(result.getString("name"));
temp.setEmail(result.getString("email"));
temp.setSecondaryEmail(result.getString("secondaryEmail"));
temp.setTypeAccount(result.getString("typeAccount"));
temp.setPassword(result.getString("password"));
temp.setAdmin(result.getBoolean("isAdministrator"));
accounts.add(temp);
}
} else {
ResultSet result = Utility.queryOperation(connect, sql);
Account temp = new Account();
while (result.next()) {
temp.setName(result.getString("name"));
temp.setEmail(result.getString("email"));
temp.setSecondaryEmail(result.getString("secondaryEmail"));
temp.setTypeAccount(result.getString("typeAccount"));
temp.setPassword(result.getString("password"));
temp.setAdmin(result.getBoolean("isAdministrator"));
accounts.add(temp);
}
}
} finally {
DBConnection.releaseConnection(connect);
}
return accounts;
}
// method to input accounts
private static HashMap<String, Account> inputAccounts(HashMap<String, Account> acctMap) {
Scanner sc = new Scanner(System.in);
String accountNumber = "";
Account account;
System.out.print("Please enter account number (enter -1 to stop entering account)");
accountNumber = sc.next();
sc.nextLine();
while (!accountNumber.equals("-1")) {
// if account has been existed, get the current balance from hashmap
if (acctMap.containsKey(accountNumber)) {
// show it to console
account = acctMap.get(accountNumber);
System.out.println("Account existed, balance = " + account.getBalance());
}
// if account has not created, add to hashmap
else {
account = new Account();
// set account number
account.setAcctNumber(accountNumber);
// prompt for name
System.out.print("Enter the name for acct # " + accountNumber + ": ");
account.setName(sc.nextLine());
// promp user for initial balance
boolean isValidAmount = false;
String amountStr = "";
while (!isValidAmount) {
System.out.print("Please enter balance amount: ");
amountStr = sc.next();
isValidAmount = Validator.validateDoubleWithRange(amountStr, 0, 1000000000);
if (!isValidAmount) {
System.out.println("Invalid amount, please try again!");
}
}
account.setBalance(Double.parseDouble(amountStr));
acctMap.put(account.getAcctNumber(), account);
}
System.out.print("Please enter account number (enter -1 to stop entering account): ");
accountNumber = sc.next();
sc.nextLine();
}
return acctMap;
}
private void createAccounts(final Context context) {
persistence.runInTransaction(
em -> {
Account account;
account = metadata.create(Account.class);
account.setName("Credit card");
account.setCurrency(context.rubCurrency);
em.persist(account);
context.accounts.add(account);
account = metadata.create(Account.class);
account.setName("Cash");
account.setCurrency(context.rubCurrency);
em.persist(account);
context.accounts.add(account);
account = metadata.create(Account.class);
account.setName("Deposit");
account.setCurrency(context.rubCurrency);
em.persist(account);
context.accounts.add(account);
account = metadata.create(Account.class);
account.setName("Deposit USD");
account.setCurrency(context.usdCurrency);
em.persist(account);
context.accounts.add(account);
account = metadata.create(Account.class);
account.setName("Deposit EUR");
account.setCurrency(context.eurCurrency);
em.persist(account);
context.accounts.add(account);
});
}
public static void getAccounts() {
String get_accounts = "select * from BANK_ACCT";
// creating PreparedStatement object to execute query
try {
PreparedStatement preStatement = conn.prepareStatement(get_accounts);
ResultSet result = preStatement.executeQuery();
while (result.next()) {
Account account_object = new Account();
account_object.setName(result.getString("NAME"));
account_object.setBalance(Double.parseDouble(result.getString("BALANCE")));
account_object.setAcc_number(Integer.parseInt(result.getString("ACC_NUMBER")));
account_object.setAcc_type((result.getString("ACC_TYPE")));
list.add(account_object);
}
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
public void action() {
try {
ContentElement content = getContentManager().extractContent(request);
CreateAccount ca = (CreateAccount) ((Action) content).getAction();
Account acc = new Account();
String id = generateId();
acc.setId(id);
acc.setName(ca.getName());
Result result = new Result((Action) content, acc);
ACLMessage reply = request.createReply();
reply.setPerformative(ACLMessage.INFORM);
getContentManager().fillContent(reply, result);
send(reply);
accounts.put(id, acc);
operations.put(id, new ArrayList());
System.out.println("Account [" + acc.getName() + " # " + acc.getId() + "] created!");
} catch (Exception ex) {
ex.printStackTrace();
}
}
private Account parseAccount(Node node) {
String id = getAttribute(node, ACCOUNT_ATTR_ID);
String type = getAttribute(node, ACCOUNT_ATTR_TYPE, "");
String name = getAttribute(node, ACCOUNT_ATTR_NAME, "");
String comment = getAttribute(node, ACCOUNT_ATTR_COMMENT, "");
HashMap<String, String> params = new HashMap<String, String>();
NodeList nodes = node.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
Node subNode = nodes.item(i);
if (subNode.getNodeType() != Node.ELEMENT_NODE) {
continue;
}
if (PARAM_NODE_NAME.equals(subNode.getNodeName())) {
String pName = getAttribute(subNode, PARAM_ATTR_NAME);
String pValue = getAttribute(subNode, PARAM_ATTR_VALUE);
if (pName != null && pValue != null) {
params.put(pName, pValue);
}
}
}
Account account;
if (SSHAccount.SSHACCOUNT_TYPE.equalsIgnoreCase(type)) {
account = new SSHAccount();
} else if (HTTPAccount.HTTPACCOUNT_TYPE.equalsIgnoreCase(type)) {
account = new HTTPAccount();
} else {
account = new Account();
}
account.setId(id);
account.setType(type);
account.setName(name);
account.setComment(comment);
account.setParams(params);
accounts.put(account.getId(), account);
String through = account.getParams().get(ACCOUNT_PARAM_THROUGH);
if (!Util.isEmptyOrNull(through)) {
needsThrough.put(account, through);
}
return account;
}
/** Test for fetching zobjects when there is an object that matches the query */
@Test
public void getInvoice() throws Exception {
// Setup Product details
String productId = getTestProduct();
String productRatePlanId = getTestProductRatePlan(productId);
String productRateplanChargeId = getTestProductRatePlanCharge(productRatePlanId);
assertNotNull(productId);
assertNotNull(productRatePlanId);
assertNotNull(productRateplanChargeId);
SubscribeRequest subscribeReq = new SubscribeRequest();
// subscribeReq.setAccount(testAccount());
String uniqueString = UUID.randomUUID().toString();
Contact contact = new Contact();
contact.setFirstName(uniqueString);
contact.setLastName(uniqueString);
Account account = new Account();
account.setName(uniqueString);
account.setBillCycleDay(1);
account.setCurrency("USD");
account.setAllowInvoiceEdit(false);
account.setAutoPay(false);
account.setStatus("Draft");
account.setPaymentTerm("Due Upon Receipt");
account.setBatch("Batch1");
PaymentMethod paymentMethod = new PaymentMethod();
paymentMethod.setType("CreditCard");
paymentMethod.setCreditCardNumber("5105105105105100");
paymentMethod.setCreditCardType("Visa");
paymentMethod.setCreditCardExpirationYear(2026);
paymentMethod.setCreditCardExpirationMonth(5);
paymentMethod.setCreditCardHolderName("Unit Test");
// Generate Start and stop days for subscription
XMLGregorianCalendar effectiveStartDate = null;
XMLGregorianCalendar effectiveEndDate = null;
try {
GregorianCalendar calStart = new GregorianCalendar();
// calStart.setTime(now);
calStart.add(Calendar.DATE, -1);
GregorianCalendar calEnd = new GregorianCalendar();
// calEnd.setTime(now);
calEnd.add(Calendar.DATE, 1);
effectiveStartDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(calStart);
effectiveEndDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(calStart);
} catch (DatatypeConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Subscription subscription = new Subscription();
subscription.setContractAcceptanceDate(effectiveStartDate);
subscription.setContractEffectiveDate(effectiveStartDate);
subscription.setInitialTerm(12);
subscription.setRenewalTerm(12);
RatePlan ratePlan = new RatePlan();
ratePlan.setProductRatePlanId(productRatePlanId);
RatePlanData ratePlanData = new RatePlanData();
ratePlanData.setRatePlan(ratePlan);
SubscriptionData subscriptionData = new SubscriptionData();
subscriptionData.setSubscription(subscription);
subscriptionData.getRatePlanData().add(ratePlanData);
subscribeReq.setAccount(account);
subscribeReq.setBillToContact(contact);
subscribeReq.setSoldToContact(contact);
subscribeReq.setPaymentMethod(paymentMethod);
subscribeReq.setSubscriptionData(subscriptionData);
SubscribeResult subscribeResult =
module.subscribe(Collections.singletonList(subscribeReq)).get(0);
assertTrue(subscribeResult.isSuccess());
assertEquals(0, subscribeResult.getErrors().size());
Map<String, Object> result = module.getInvoice(subscribeResult.getInvoiceId());
System.out.println("Result = " + result);
assertEquals("Posted", result.get("status"));
// assertEquals("amount",result.get("amount"));
assertNotSame(0, ((ArrayList) result.get("invoiceitems")).size());
assertNotNull(result.get("billTo"));
assertNotNull(result.get("soldTo"));
DeleteResult deleteResultAccount = null;
DeleteResult deleteResultProduct = null;
try {
deleteResultAccount =
module
.delete(
ZObjectType.Account, Collections.singletonList(subscribeResult.getAccountId()))
.get(0);
deleteResultProduct =
module.delete(ZObjectType.Product, Collections.singletonList(productId)).get(0);
} catch (Exception e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
assertTrue(deleteResultAccount.isSuccess());
assertTrue(deleteResultProduct.isSuccess());
}
// Test the getName function
@Test
public void nametest() {
Account a = new Account();
a.setName("Alice");
assertEquals(a.getName(), "Alice");
}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
int tr_id = 0;
transaction = new ArrayList<Transaction>();
list = new ArrayList<Account>();
new_list = new ArrayList<Account>(); // list for new accounts
del_list = new ArrayList<Account>(); // accounts to remove
Scanner sc = new Scanner(System.in);
Account ac = null;
try {
connectSQL();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Read accounts to arrayList
getAccounts();
// print accounts
System.out.printf("%20s%15s%15s%15s\n", "Name", "Account #", "Balance", "Account Type");
for (Account elem : list) {
System.out.printf(
"%20s%15s%15s%15s\n",
elem.getName(), elem.getAcc_number(), elem.getBalance(), elem.getAcc_type());
}
// Loops to add/remove accounts
while (true) {
boolean flag = false;
System.out.println("Enter account number or -1 to stop entering accounts: ");
String account_num = sc.nextLine();
whilelabel:
while (!Validation.validate_Account_Num(account_num)) {
System.out.println("Invalid! Enter an account number or -1 to stop entering accounts: ");
account_num = sc.nextLine();
}
if (Integer.parseInt(account_num) < 0) // EXIT
break;
else {
for (Account elem : list) {
if (Integer.parseInt(account_num) == elem.getAcc_number()) {
flag = true;
System.out.println("Account present, balance is: " + elem.getBalance());
System.out.println("Enter d to delete account, ENTER to continue ");
String response = sc.nextLine();
if (response.equalsIgnoreCase("d")) {
if (elem.getBalance() != 0) {
System.out.println("Cannot close account: Non Zero Balance");
flag = true;
break;
}
list.remove(elem);
del_list.add(elem);
System.out.println("Account removed");
System.out.println("Current Accounts:");
for (Account elem2 : list) {
System.out.printf(
"%15s%15d%15f%15s\n",
elem2.getName(),
elem2.getAcc_number(),
elem2.getBalance(),
elem2.getAcc_type());
}
}
flag = true;
break;
}
}
if (flag) continue; // continue with while
ac = new Account();
ac.setAcc_number(Integer.parseInt(account_num));
System.out.println("Enter the name for your account# " + account_num);
String name = sc.nextLine();
int type = find_Account_by_name(name);
System.out.println(type);
// if name exists check acc_type
// if both exists prompt again
if (type != 3) {
if (type == 1) {
System.out.println("Would you like to open a savings account: y/n");
String response = sc.nextLine();
if (!response.equalsIgnoreCase("y")) continue;
else {
ac.setAcc_type("Saving");
ac.setAcc_number(generate_Unique_acc_num());
}
} else if (type == 2) {
System.out.println("Would you like to open a Checking account: y/n");
String response = sc.nextLine();
if (!response.equalsIgnoreCase("y")) continue;
else ac.setAcc_type("Checking");
ac.setAcc_number(generate_Unique_acc_num());
} else if (type == 0) {
System.out.println("You have both accounts! ");
break;
}
} else // no accounts for this name
{
System.out.println("Enter c for Checking: s for Savings");
String acc_type = sc.nextLine();
if (acc_type.equalsIgnoreCase("C")) ac.setAcc_type("Checking");
else ac.setAcc_type("Saving");
}
ac.setName(name);
System.out.println("Enter the balance for account number# " + ac.getAcc_number());
ac.setBalance(Double.parseDouble(sc.nextLine()));
System.out.println("balance " + ac.getBalance());
new_list.add(ac);
}
}
// Loop to perform transactions
while (true) {
System.out.println(
"Enter a transaction type: (c:Check, dc:Debit Card, d:Deposit, tr:transfer, or w:Withdrawl) or -1 to finish");
String tr = sc.nextLine();
if ((!tr.equalsIgnoreCase("-1"))
&& (!tr.equalsIgnoreCase("w"))
&& (!tr.equalsIgnoreCase("d"))
&& (!tr.equalsIgnoreCase("c"))
&& (!tr.equalsIgnoreCase("dc"))
&& (!tr.equalsIgnoreCase("tr"))) continue;
if (tr.equalsIgnoreCase("-1")) break;
System.out.println("Enter your account# ");
String account_num = sc.nextLine();
while (!Validation.validate_Account_Num(account_num)) {
System.out.println("Invalid! Enter an account number: ");
account_num = sc.nextLine();
}
int acc_index = TransactionApp.find_Account(account_num);
if (acc_index == -1) {
System.out.println("Invalid Account #, try again");
continue;
} else {
System.out.println("Balance : " + list.get(acc_index).getBalance());
System.out.println("Enter Amount: ");
String db = sc.nextLine();
while (!Validation.validate_Amount(db)) {
System.out.println("Enter Amount: ");
db = sc.nextLine();
}
double am = Double.parseDouble(db);
;
// sc.nextLine();
System.out.println("Enter Date MM/DD/YY");
String date = sc.nextLine();
while (!Validation.validate_Date(date)) {
System.out.println("Invalid date! Enter Again: MM/DD/YY");
date = sc.nextLine();
}
if (tr.equalsIgnoreCase("d")) tr_id = 1;
else if (tr.equalsIgnoreCase("dc")) tr_id = 4;
else if (tr.equalsIgnoreCase("c")) tr_id = 2;
else if (tr.equalsIgnoreCase("w")) tr_id = 3;
else if (tr.equalsIgnoreCase("tr")) tr_id = 5;
if (tr.equalsIgnoreCase("c") || tr.equalsIgnoreCase("d")) // deposit
{
transaction.add(
Transaction.getTransaction(Integer.parseInt(account_num), am, date, tr_id));
} else if (tr.equalsIgnoreCase("tr")) {
System.out.println("Enter account number to Deposit To");
String to_acc_num = sc.nextLine();
Validation.validate_Account_Num(to_acc_num);
int index_to_acc = find_Account(to_acc_num); // need to be checked
int index_from_acc = find_Account(account_num);
while (true) {
if (list.get(index_from_acc).getBalance() < am) {
System.out.println(
"Insufficient Funds, current balance : " + list.get(index_from_acc).getBalance());
System.out.println("Enter another amount ");
String new_amount = sc.nextLine();
am = Double.parseDouble(new_amount);
} else break;
}
transaction.add(
Transaction.getTransaction(Integer.parseInt(to_acc_num), am, date, tr_id)); // deposit
am = 0 - am;
transaction.add(
Transaction.getTransaction( // withdraw
Integer.parseInt(account_num), am, date, tr_id));
} else // Withdrawal
{
double rem_bal = 0;
String ac_type = list.get(find_Account(account_num)).getAcc_type();
if (ac_type.equalsIgnoreCase("Checking")) {
double c_balance = list.get(find_Account(account_num)).getBalance();
if (c_balance < am) {
String cust_name = list.get(find_Account(account_num)).getName();
int type = find_Account_by_name(cust_name);
if (type == 0) // has a saving account
{
System.out.println("Came here");
int acc_num2 = get_account_savings(cust_name);
double s_balance = list.get(find_Account(Integer.toString(acc_num2))).getBalance();
if (c_balance + s_balance < am) {
System.out.println("Insufficient funds");
continue;
} else {
rem_bal = 0 - am + c_balance - 15;
double c_bal = 0 - c_balance;
transaction.add(
Transaction.getTransaction(
Integer.parseInt(account_num), c_bal, date, tr_id));
transaction.add(Transaction.getTransaction(acc_num2, rem_bal, date, tr_id));
continue;
}
} else {
System.out.println("Insufficient funds");
continue;
}
}
}
am = 0 - am;
transaction.add(
Transaction.getTransaction(Integer.parseInt(account_num), am, date, tr_id));
}
}
}
sc.close();
Collections.sort(transaction);
printTransactions();
perform_Transactions();
// printAccounts();
// write back the modified account info
removeAccounts();
addAccounts();
upDateDB();
}
public static void main(String[] args) {
Scanner key = new Scanner(System.in);
Validator val = new Validator();
// Initializing parameters for account class
String account_number;
String name;
String starting_balance;
String birth_date;
// Initializing parameters for transaction class.
// private String account_number;
String transaction_type_id = "";
String amount = "";
String transaction_date = "";
// Operator + for deposit, - for other transaction.
String operator;
// Add account information into the database.
AccountDBHelper all_in_sql = new AccountDBHelper();
System.out.println("Welcome to Evil Corp bank Accounts");
while (true) {
Account account = new Account();
// Entering account number or -1 to exit.
System.out.println("Enter account number or -1 to exit entering account: ");
account_number = key.next();
key.nextLine();
if (account_number.equalsIgnoreCase("-1")) {
break;
}
// Increment ID by one for each account added.
account.setAccount_number(account_number);
// Enter the account name.
System.out.println("Enter the account name : ");
name = key.next();
key.nextLine();
account.setName(name);
// Enter Starting balance.
System.out.println("Enter the starting balance : ");
starting_balance = key.next();
key.nextLine();
balance_loop:
while (true) {
if (val.validateIntWithRange(starting_balance, 1, 1000000)) {
break balance_loop;
} else {
System.out.println("Invalid account number, try again.");
System.out.println("Enter the starting balance : ");
starting_balance = key.next();
key.nextLine();
}
}
account.setStarting_balance(Double.parseDouble(starting_balance));
// Enter birth date as the format "mm/dd/yyyy", no other formats accepted.
System.out.println("Enter the date of birth : ");
birth_date = key.next();
key.nextLine();
date_loop:
while (true) {
if (val.validateDateWithFormat(birth_date)) {
break date_loop;
} else {
System.out.println("Invalid date, try again.");
System.out.println("Enter the date of birth : format(mm/dd/yyyy)");
birth_date = key.next();
key.nextLine();
}
}
// mm/dd/yyyy
SimpleDateFormat sdf = new SimpleDateFormat("mm/dd/yyyy");
try {
account.setBirth_date(sdf.parse(birth_date));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// System.out.println(account.getAccount_number());
all_in_sql.insertAccount(account);
}
System.out.println("Welcome to Evil Corp bank Transactions");
transaction_loop:
while (true) {
System.out.println("Enter account number or -1 to exit transactions: ");
account_number = key.next();
key.nextLine();
if (account_number.equalsIgnoreCase("-1")) {
break transaction_loop;
}
// Look for the account number and see if that in the database.
boolean hasAccount = false;
while (!hasAccount) {
if (account_number.equalsIgnoreCase("-1")) {
break transaction_loop;
}
Account account = all_in_sql.getAccountFromNumber(account_number);
if (account.getAccount_number() != null) {
hasAccount = true;
} else {
System.out.println("Account not found! Please try again");
System.out.println("Enter account number or -1 to exit transactions: ");
account_number = key.next();
key.nextLine();
}
}
boolean validType = false;
while (!validType) {
System.out.println(
"Enter the transaction type: \n"
+ "1 - Deposite.\n"
+ "2 - Check.\n"
+ "3 - Withdrawal.\n"
+ "4 - Debit Card.");
transaction_type_id = key.next();
key.nextLine();
validType = val.validateIntWithRange(transaction_type_id, 1, 4);
if (!validType) {
System.out.println("Invalid type, please try again!");
}
}
Transaction transaction = new Transaction();
//
transaction.setAccount_number(account_number);
// set tran type id
transaction.setTransaction_type_id(Integer.parseInt(transaction_type_id));
validType = false;
while (!validType) {
System.out.println("Enter Transaction amount: ");
amount = key.next();
key.nextLine();
validType = val.validateDoubleWithRange(amount, 0, 10000000);
if (!validType) {
System.out.println("Invalid amount, please try again! (from 0 to 10000000)");
}
}
// set tran amount
transaction.setAmount(Double.parseDouble(amount));
validType = false;
while (!validType) {
System.out.println("Enter Transaction date: (MM/DD/YYYY)");
transaction_date = key.next();
key.nextLine();
validType = val.validateDateWithFormat(transaction_date);
if (!validType) {
System.out.println("Invalid date, try insert date (MM/DD/YYYY): ");
}
}
SimpleDateFormat sdf = new SimpleDateFormat("mm/dd/yyyy");
try {
transaction.setTransaction_date(sdf.parse(transaction_date));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// transaction.process_transaction(account);
all_in_sql.addTransaction(transaction);
// Process transaction.
}
}
/** Stores to persistence layer initial data. */
@PostConstruct
public void init() {
if (roleRepository.findByName("ROLE_ADMIN") == null) {
Role roleUser = new Role();
roleUser.setName("ROLE_USER");
roleRepository.save(roleUser);
Role roleAdmin = new Role();
roleAdmin.setName("ROLE_ADMIN");
roleRepository.save(roleAdmin);
User user = new User();
user.setEnabled(true);
user.setEmail("admin@admin");
BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
user.setPassword(encoder.encode("admin"));
List<Role> roles = new ArrayList<>();
roles.add(roleAdmin);
roles.add(roleUser);
user.setRoles(roles);
userRepository.save(user);
// Create account for wallet
Account walletAccount = new Account();
walletAccount.setName(context.getMessage("Name.default.account", null, Locale.ENGLISH));
walletAccount.setUser(user);
walletAccount.setAmount(new BigDecimal(0));
walletAccount.setCurrency(Currency.getInstance("UAH"));
accountRepository.save(walletAccount);
Account bankAccount = new Account();
bankAccount.setName("Bank");
bankAccount.setUser(user);
bankAccount.setAmount(new BigDecimal(500));
bankAccount.setCurrency(Currency.getInstance("UAH"));
accountRepository.save(bankAccount);
// Create categories for expenses
for (int i = 1; i < 6; i++) {
Category category = new Category();
category.setName(
context.getMessage("Name" + i + ".default.category", null, Locale.ENGLISH));
category.setType(Operation.EXPENSE);
category.setUser(user);
categoryRepository.save(category);
}
// Create categories for incomes
for (int i = 6; i < 8; i++) {
Category category = new Category();
category.setName(
context.getMessage("Name" + i + ".default.category", null, Locale.ENGLISH));
category.setType(Operation.INCOME);
category.setUser(user);
categoryRepository.save(category);
}
Transaction transaction1 = new Transaction();
transaction1.setDate(new Date());
transaction1.setAccount(walletAccount);
transaction1.setAmount(new BigDecimal(50));
transaction1.setCurrency(Currency.getInstance("UAH"));
transaction1.setCategory(categoryRepository.findOne(3));
transaction1.setType(Operation.EXPENSE);
transaction1.setComment("McDonalds");
transaction1.setUser(user);
transactionRepository.save(transaction1);
Transaction transaction2 = new Transaction();
Calendar calendar = new GregorianCalendar();
calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1);
transaction2.setDate(calendar.getTime());
transaction2.setAccount(bankAccount);
transaction2.setAmount(new BigDecimal(45));
transaction2.setCurrency(Currency.getInstance("UAH"));
transaction2.setCategory(categoryRepository.findOne(7));
transaction2.setType(Operation.INCOME);
transaction2.setComment("Festo");
transaction2.setUser(user);
transactionRepository.save(transaction2);
List<Transaction> transactions = new ArrayList<>();
transactions.add(transaction1);
user.setTransactions(transactions);
}
}
