public void printAllAccounts(String customerID) { // Sorts the customer based on ID, then prints the accounts information // change the withdrawal funcitons and deposit functions too ajf.dispose(); ajf = new AdminRunningFrame(this); Collections.sort(cust, Customer.CompareIDs); String searchString = ajf.getCustomerID(); StringBuilder stringResults = new StringBuilder(); String header = header(); stringResults.append(header); for (Customer customer : cust) { String id = customer.returnID(); String name = customer.getName().toUpperCase(); String pin = customer.returnPin(); if (searchString.equals(id)) { ArrayList<Account> accounts = customer.getAccounts(); if (!accounts.isEmpty()) { for (Account account : accounts) { if (account.checkActive()) { String accountNumber = account.returnNumber(); double balance = account.returnBalance(); String balanceAsString = formatter.format(balance); String customerInfo = printAdminInfo(name, id, accountNumber, pin, balanceAsString); stringResults.append(customerInfo); } } } } } String resultsAsString = stringResults.toString(); ajf.printInfo(resultsAsString); }
/* update title string */ public static void updateAccountString( Account account, String stringID, String description, String singular, String plural) throws DBException { /* valid account? */ if (account == null) { throw new DBException("Account not specified."); } /* delete? */ // delete if both singular/plural values are empty/null if (((singular == null) || singular.equals("")) && ((plural == null) || plural.equals(""))) { String acctID = account.getAccountID(); AccountString.Key key = new AccountString.Key(acctID, stringID); key.delete(true); // also delete dependencies (if any) return; } /* get/create AccountString */ AccountString str = AccountString.getAccountString(account, stringID); if (str == null) { str = AccountString.getAccountString(account, stringID, true); } /* insert/update */ str.setDescription(description); str.setSingularTitle(singular); str.setPluralTitle((plural != null) ? plural : singular); str.save(); }
/* overridden to set default values */ public void setCreationDefaultValues() { BasicPrivateLabel privateLabel = Account.getPrivateLabel(this.getAccount()); StatusCodes.Code code = StatusCodes.GetCode(this.getStatusCode(), privateLabel); this.setStatusName((code != null) ? code.getName() : ""); this.setDescription((code != null) ? code.getDescription(null) : ""); this.setIconSelector(""); // super.setRuntimeDefaultValues(); }
/* Return specified StatusCode, create if specified */ private static StatusCode _getStatusCode( String accountID, Account account, String deviceID, int code, boolean createOK) throws DBException { // does not return null if 'createOK' is true /* account-id specified? */ if (StringTools.isBlank(accountID)) { if (account == null) { throw new DBException("Account not specified."); } else { accountID = account.getAccountID(); } } else if ((account != null) && !account.getAccountID().equals(accountID)) { throw new DBException("Account does not match specified AccountID."); } /* device-id specified? */ if (StringTools.isBlank(deviceID)) { // throw new DBException("Device-ID not specified."); deviceID = ALL_DEVICES; } /* get/create entity */ StatusCode.Key scKey = new StatusCode.Key(accountID, deviceID, code); if (scKey.exists()) { // may throw DBException StatusCode sc = scKey.getDBRecord(true); if (account != null) { sc.setAccount(account); } return sc; } else if (createOK) { StatusCode sc = scKey.getDBRecord(); if (account != null) { sc.setAccount(account); } sc.setCreationDefaultValues(); return sc; // not yet saved! } else { // record doesn't exist, and caller doesn't want us to create it return null; } }
public void printByCustomerName() { // Prints the database info by customer's name in ascending order Collections.sort(cust, Customer.CompareName); ajf.dispose(); ajf = new AdminRunningFrame(this); StringBuilder stringResults = new StringBuilder(); String header = header(); stringResults.append(header); if (!cust.isEmpty()) { for (Customer customer : cust) { String id = customer.returnID(); String name = customer.getName().toUpperCase(); String pin = customer.returnPin(); ArrayList<Account> accounts = customer.getAccounts(); if (!accounts.isEmpty()) { for (Account account : accounts) { if (account.checkActive()) { String accountNumber = account.returnNumber(); double balance = account.returnBalance(); String balanceAsString = formatter.format(balance); String customerInfo = printAdminInfo(name, id, accountNumber, pin, balanceAsString); stringResults.append(customerInfo); } } } else { // Still prints customers who have created customer accounts but not set up any // checking/savings String noAccounts = String.format("%-20s %-9s %-10s\n", name, id, pin); stringResults.append(noAccounts); } } } String resultsAsString = stringResults.toString(); ajf.printInfo(resultsAsString); }
public void printHighestBalance() { // prints the accounts from highest amount to lowest, with those who have empty accounts last ajf.dispose(); ajf = new AdminRunningFrame(this); StringBuilder stringResults = new StringBuilder(); String header = header(); stringResults.append(header); if (!cust.isEmpty()) { ArrayList<Account> allAccounts = new ArrayList<Account>(); ArrayList<Customer> CustomersNoAccounts = new ArrayList<Customer>(); for (Customer c : cust) { ArrayList<Account> accounts = c.getAccounts(); if (!accounts.isEmpty()) { // Concatenates all the accounts together for easy sorting allAccounts.addAll(accounts); } // Adds customers without accounts to a separate list to be printed at the end of all the // others else { CustomersNoAccounts.add(c); } } if (!allAccounts.isEmpty()) { Collections.sort(allAccounts, Account.CompareBalances); for (Account a : allAccounts) { if (a.checkActive()) { String id = a.getID(); String name = a.getName().toUpperCase(); String pin = a.getPin(); String accountNumber = a.returnNumber(); double balance = a.returnBalance(); String balanceAsString = formatter.format(balance); String customerInfo = printAdminInfo(name, id, accountNumber, pin, balanceAsString); stringResults.append(customerInfo); } } } if (!CustomersNoAccounts.isEmpty()) { Collections.sort(CustomersNoAccounts, Customer.CompareName); for (Customer c : CustomersNoAccounts) { String id = c.returnID(); String name = c.getName().toUpperCase(); String pin = c.returnPin(); String noAccounts = String.format("%-20s %-9s %-10s\n", name, id, pin); stringResults.append(noAccounts); } } String resultsAsString = stringResults.toString(); ajf.printInfo(resultsAsString); } }
public static DBFactory<AccountString> getFactory() { if (factory == null) { factory = DBFactory.createDBFactory( AccountString.TABLE_NAME(), AccountString.FieldInfo, DBFactory.KeyType.PRIMARY, AccountString.class, AccountString.Key.class, true /*editable*/, true /*viewable*/); factory.addParentTable(Account.TABLE_NAME()); } return factory; }
/* get string */ public static AccountString getAccountString(Account account, String strID) throws DBException { if ((account != null) && (strID != null)) { String acctID = account.getAccountID(); AccountString.Key key = new AccountString.Key(acctID, strID); if (key.exists()) { AccountString str = key.getDBRecord(true); str.setAccount(account); return str; } else { // AccountString does not exist return null; } } else { return null; // just say it doesn't exist } }
public static DBFactory<RoleAcl> getFactory() { if (factory == null) { EnumTools.registerEnumClass(AccessLevel.class); factory = DBFactory.createDBFactory( RoleAcl.TABLE_NAME(), RoleAcl.FieldInfo, DBFactory.KeyType.PRIMARY, RoleAcl.class, RoleAcl.Key.class, true /*editable*/, true /*viewable*/); factory.addParentTable(Account.TABLE_NAME()); factory.addParentTable(Role.TABLE_NAME()); } return factory; }
public static DBFactory<StatusCode> getFactory() { if (factory == null) { factory = DBFactory.createDBFactory( StatusCode.TABLE_NAME(), StatusCode.FieldInfo, DBFactory.KeyType.PRIMARY, StatusCode.class, StatusCode.Key.class, true /*editable*/, true /*viewable*/); factory.addParentTable(Account.TABLE_NAME()); factory.addParentTable(Device.TABLE_NAME()); factory.setFieldDefaultValue(FLD_deviceID, ALL_DEVICES); } return factory; }
public static DBFactory<GroupList> getFactory() { if (factory == null) { factory = DBFactory.createDBFactory( GroupList.TABLE_NAME(), GroupList.FieldInfo, DBFactory.KeyType.PRIMARY, GroupList.class, GroupList.Key.class, true /*editable*/, true /*viewable*/); factory.addParentTable(Account.TABLE_NAME()); factory.addParentTable(User.TABLE_NAME()); factory.addParentTable(DeviceGroup.TABLE_NAME()); } return factory; }
public void tally_account_bip_status(Account account) { try { if (account.is_bipstatus(Account.SUCCEEDED)) { ++num_accounts_bip_succeeded; if (account.was_local_run()) { total_local_cpu_time += account.get_final_cpu_time(); total_local_wall_time += account.get_final_wall_time(); } else { total_foreign_cpu_time += account.get_final_cpu_time(); total_foreign_wall_time += account.get_final_wall_time(); } } else if (account.is_bipstatus(Account.FAILED)) ++num_accounts_bip_failed; else if (account.is_bipstatus(Account.SKIPPED)) ++num_accounts_bip_skipped; } catch (Exception e) { BICServerLog.infoMsg("tally_account_bip_status() caught Exception." + e); } return; }
protected Device loadDevice(String acctID, String devID) { if (StringTools.isBlank(acctID)) { return this.loadDevice(devID); // load ad ModemID } else { try { Account account = Account.getAccount(acctID); if (account == null) { Print.logError("Account-ID not found: " + acctID); return null; } else { Device dev = Transport.loadDeviceByTransportID(account, devID); return dev; } } catch (DBException dbe) { Print.logError("Error getting Device: " + acctID + "/" + devID + " [" + dbe + "]"); return null; } } }
// Note: does NOT return null public static AccountString getAccountString(Account account, String strID, boolean create) throws DBException { /* account-id specified? */ if (account == null) { throw new DBNotFoundException("Account not specified."); } String acctID = account.getAccountID(); /* string-id specified? */ if ((strID == null) || strID.equals("")) { throw new DBNotFoundException("String-ID not specified for account: " + acctID); } /* get/create */ AccountString str = null; AccountString.Key strKey = new AccountString.Key(acctID, strID); if (!strKey.exists()) { if (create) { str = strKey.getDBRecord(); str.setAccount(account); str.setCreationDefaultValues(); return str; // not yet saved! } else { throw new DBNotFoundException("String-ID does not exists: " + strKey); } } else if (create) { // we've been asked to create the AccountString, and it already exists throw new DBAlreadyExistsException("String-ID already exists '" + strKey + "'"); } else { str = AccountString.getAccountString(account, strID); if (str == null) { throw new DBException("Unable to read existing String-ID: " + strKey); } return str; } }
public static void main(String args[]) { DBConfig.cmdLineInit(args, true); // main String acctID = RTConfig.getString(ARG_ACCOUNT, ""); String roleID = RTConfig.getString(ARG_ROLE, ""); String aclID = RTConfig.getString(ARG_ACL, ""); /* account-id specified? */ if ((acctID == null) || acctID.equals("")) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account acct = null; try { acct = Account.getAccount(acctID); // may return DBException if (acct == null) { Print.logError("Account-ID does not exist: " + acctID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + acctID, dbe); // dbe.printException(); System.exit(99); } /* role-id specified? */ if ((roleID == null) || roleID.equals("")) { Print.logError("Role-ID not specified."); usage(); } /* get role */ Role role = null; try { role = Role.getRole(acct, roleID); // may return DBException if (role == null) { Print.logError("Role-ID does not exist: " + acctID + "/" + roleID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Role: " + acctID + "/" + roleID, dbe); // dbe.printException(); System.exit(99); } /* RoleAcl exists? */ boolean aclExists = false; if ((aclID != null) && !aclID.equals("")) { try { aclExists = RoleAcl.exists(acctID, roleID, aclID); } catch (DBException dbe) { Print.logError( "Error determining if RoleAcl exists: " + acctID + "/" + roleID + "/" + aclID); System.exit(99); } } /* option count */ int opts = 0; /* list */ if (RTConfig.getBoolean(ARG_LIST, false)) { opts++; try { String aclList[] = role.getAclsForRole(); for (int i = 0; i < aclList.length; i++) { AccessLevel level = RoleAcl.getAccessLevel(role, aclList[i], AccessLevel.NONE); Print.sysPrintln(" " + aclList[i] + " ==> " + level); } } catch (DBException dbe) { Print.logError("Error getting Acl list: " + dbe); System.exit(99); } System.exit(0); } /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false) && !acctID.equals("") && !roleID.equals("")) { opts++; if (!aclExists) { Print.logWarn("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID); Print.logWarn("Continuing with delete process ..."); } try { RoleAcl.Key aclKey = new RoleAcl.Key(acctID, roleID, aclID); aclKey.delete(true); // also delete dependencies Print.logInfo("RoleAcl deleted: " + acctID + "/" + roleID + "/" + aclID); } catch (DBException dbe) { Print.logError("Error deleting RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (aclExists) { Print.logWarn("RoleAcl already exists: " + acctID + "/" + roleID + "/" + aclID); } else { try { RoleAcl.createNewRoleAcl(role, aclID); Print.logInfo("Created RoleAcl: " + acctID + "/" + roleID + "/" + aclID); aclExists = true; } catch (DBException dbe) { Print.logError("Error creating RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } } } /* set */ if (RTConfig.hasProperty(ARG_SET)) { opts++; AccessLevel aclLevel = EnumTools.getValueOf(AccessLevel.class, RTConfig.getInt(ARG_SET, -1)); try { RoleAcl.setAccessLevel(role, aclID, aclLevel); Print.logInfo( "Set RoleAcl '" + acctID + "/" + roleID + "/" + aclID + "' to level " + aclLevel); } catch (DBException dbe) { Print.logError("Error setting RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } System.exit(0); } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!aclExists) { Print.logError("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID); } else { try { RoleAcl roleAcl = RoleAcl.getRoleAcl(role, aclID, false); // may throw DBException DBEdit editor = new DBEdit(roleAcl); editor.edit(); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError("Error editing RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); } } System.exit(0); } /* no options specified */ if (opts == 0) { Print.logWarn("Missing options ..."); usage(); } }
public static void main(String argv[]) { DBConfig.cmdLineInit(argv, true); // main String accountID = RTConfig.getString(ARG_ACCOUNT, ""); String deviceID = RTConfig.getString(ARG_DEVICE, ""); int statusCode = RTConfig.getInt(ARG_CODE, 0); boolean anyCode = true; // RTConfig.hasProperty(ARG_ECODE); /* account-id specified? */ if (StringTools.isBlank(accountID)) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account account = null; try { account = Account.getAccount(accountID); // may throw DBException if (account == null) { Print.logError("Account-ID does not exist: " + accountID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + accountID, dbe); // dbe.printException(); System.exit(99); } /* device-id specified? */ if (StringTools.isBlank(deviceID) || deviceID.startsWith("/")) { deviceID = ALL_DEVICES; } /* check device existance */ if (!deviceID.equals(ALL_DEVICES)) { try { Device device = Device.getDevice(account, deviceID); // may throw DBException if (device == null) { Print.logError("Device-ID does not exist: " + accountID + " / " + deviceID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Device: " + accountID + " / " + deviceID, dbe); System.exit(99); } } /* status-code specified? */ if ((statusCode > 0) && !anyCode && !StatusCodes.IsValid(statusCode, account.getPrivateLabel())) { Print.logError("Invalid Status Code specified."); usage(); } /* statusCode specified? */ if (statusCode <= 0) { Print.logError("StatusCode not specified."); usage(); } /* statusCode exists? */ boolean statusCodeExists = false; try { statusCodeExists = StatusCode.exists(accountID, deviceID, statusCode); } catch (DBException dbe) { Print.logError( "Error determining if StatusCode exists: " + accountID + "/" + deviceID + "/" + statusCode); System.exit(99); } /* option count */ int opts = 0; /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false)) { opts++; if (!statusCodeExists) { Print.logWarn( "StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode); Print.logWarn("Continuing with delete process ..."); } try { StatusCode.Key scKey = new StatusCode.Key(accountID, deviceID, statusCode); scKey.delete(true); // also delete dependencies (if any) Print.logInfo("StatusCode deleted: " + accountID + "/" + deviceID + "/" + statusCode); statusCodeExists = false; } catch (DBException dbe) { Print.logError( "Error deleting StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (statusCodeExists) { Print.logWarn( "StatusCode already exists: " + accountID + "/" + deviceID + "/" + statusCode); } else { try { StatusCode.createNewStatusCode(account, deviceID, statusCode); Print.logInfo("Created StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); statusCodeExists = true; } catch (DBException dbe) { Print.logError( "Error creating StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); System.exit(99); } } } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!statusCodeExists) { Print.logError( "StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode); } else { try { StatusCode sc = StatusCode.getStatusCode(account, deviceID, statusCode); // may throw DBException DBEdit editor = new DBEdit(sc); editor.edit(); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError( "Error editing StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); } } System.exit(0); } /* list */ if (RTConfig.hasProperty(ARG_LIST)) { opts++; String listType = RTConfig.getString(ARG_LIST, null); // TODO: complete ... } /* no options specified */ if (opts == 0) { Print.logWarn("Missing options ..."); usage(); } }
public static void main(String args[]) { DBConfig.cmdLineInit(args, true); // main String acctID = RTConfig.getString(ARG_ACCOUNT, ""); String strID = RTConfig.getString(ARG_STRING, ""); /* account-id specified? */ if (StringTools.isBlank(acctID)) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account acct = null; try { acct = Account.getAccount(acctID); // may throw DBException if (acct == null) { Print.logError("Account-ID does not exist: " + acctID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + acctID, dbe); // dbe.printException(); System.exit(99); } /* string-id specified? */ if ((strID == null) || strID.equals("")) { Print.logError("String-ID not specified."); usage(); } /* string exists? */ boolean stringExists = false; try { stringExists = AccountString.exists(acctID, strID); } catch (DBException dbe) { Print.logError("Error determining if AccountString exists: " + _fmtStrID(acctID, strID)); System.exit(99); } /* option count */ int opts = 0; /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false) && !acctID.equals("") && !strID.equals("")) { opts++; if (!stringExists) { Print.logWarn("AccountString does not exist: " + _fmtStrID(acctID, strID)); Print.logWarn("Continuing with delete process ..."); } try { AccountString.Key strKey = new AccountString.Key(acctID, strID); strKey.delete(true); // also delete dependencies Print.logInfo("AccountString deleted: " + _fmtStrID(acctID, strID)); stringExists = false; } catch (DBException dbe) { Print.logError("Error deleting AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (stringExists) { Print.logWarn("AccountString already exists: " + _fmtStrID(acctID, strID)); } else { try { AccountString.createNewAccountString(acct, strID); Print.logInfo("Created AccountString: " + _fmtStrID(acctID, strID)); stringExists = true; } catch (DBException dbe) { Print.logError("Error creating AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); System.exit(99); } } } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!stringExists) { Print.logError("AccountString does not exist: " + _fmtStrID(acctID, strID)); } else { try { AccountString str = AccountString.getAccountString(acct, strID, false); // may throw DBException DBEdit editor = new DBEdit(str); editor.edit(true); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError("Error editing AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); } } System.exit(0); } /* no options specified */ if (opts == 0) { Print.logWarn("Missing options ..."); usage(); } }