public class AccountString extends AccountRecord<AccountString> { // ------------------------------------------------------------------------ public static final String ID_ACCOUNT = "account"; // "Account", "Company", ... public static final String ID_USER = "******"; // "User", "Associate", ... public static final String ID_DEVICE = "device"; // "Device", "Tractor", "Taxi", ... public static final String ID_DEVICE_NEW_DESCRIPTION = "deviceDesc"; // "New Device" public static final String ID_DEVICE_GROUP = "deviceGroup"; // "Device Group", "Group", "Fleet", "Crowd", ... public static final String ID_ENTITY = "entity"; // "Entity", "Trailer", ... public static final String ID_PING_DEVICE = "pingDevice"; // "Ping Device", "Locate {0}", "Locate Now", ... public static final String ID_ADDRESS = "address"; // "Address", "Landmark", ... public static final String ID_KEYS[] = new String[] { ID_ACCOUNT, ID_USER, ID_DEVICE, ID_DEVICE_NEW_DESCRIPTION, ID_DEVICE_GROUP, ID_ENTITY, ID_PING_DEVICE, ID_ADDRESS }; // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // SQL table definition below /* table name */ private static final String _TABLE_NAME = "AccountString"; public static String TABLE_NAME() { return DBProvider._translateTableName(_TABLE_NAME); } /* field definition */ public static final String FLD_stringID = "stringID"; public static final String FLD_singularTitle = "singularTitle"; public static final String FLD_pluralTitle = "pluralTitle"; private static DBField FieldInfo[] = { // String fields: newField_accountID(true), new DBField( FLD_stringID, String.class, DBField.TYPE_ID(), "String ID", "key=true editor=accountString"), new DBField( FLD_singularTitle, String.class, DBField.TYPE_STRING(64), "Singular Title", "edit=2"), new DBField(FLD_pluralTitle, String.class, DBField.TYPE_STRING(64), "Plural Title", "edit=2"), // Common fields newField_description(), newField_lastUpdateTime(), newField_creationTime(), }; /* key class */ public static class Key extends AccountKey<AccountString> { public Key() { super(); } public Key(String acctId, String strKey) { super.setFieldValue(FLD_accountID, ((acctId != null) ? acctId.toLowerCase() : "")); super.setFieldValue(FLD_stringID, ((strKey != null) ? strKey.toLowerCase() : "")); } public DBFactory<AccountString> getFactory() { return AccountString.getFactory(); } } /* factory constructor */ private static DBFactory<AccountString> factory = null; 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; } /* Bean instance */ public AccountString() { super(); } /* database record */ public AccountString(AccountString.Key key) { super(key); } // ------------------------------------------------------------------------ /* table description */ public static String getTableDescription(Locale loc) { I18N i18n = I18N.getI18N(AccountString.class, loc); return i18n.getString( "AccountString.description", "This table defines " + "Account specific customized String key/values."); } // SQL table definition above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Bean access fields below /* return the String ID for this record */ public String getStringID() { String v = (String) this.getFieldValue(FLD_stringID); return StringTools.trim(v); } /* set the String ID for this record */ private void setStringID(String v) { this.setFieldValue(FLD_stringID, StringTools.trim(v)); } // ------------------------------------------------------------------------ /* return the singular title */ public String getSingularTitle() { String v = (String) this.getFieldValue(FLD_singularTitle); return StringTools.trim(v); } /* return true if singular title is defined */ public boolean hasSingularTitle() { return !this.getSingularTitle().equals(""); } /* set the singular title */ public void setSingularTitle(String v) { this.setFieldValue(FLD_singularTitle, StringTools.trim(v)); } // ------------------------------------------------------------------------ /* return the plural title */ public String getPluralTitle() { String v = (String) this.getFieldValue(FLD_pluralTitle); return StringTools.trim(v); } /* return true if plural title is defined */ public boolean hasPluralTitle() { return !this.getPluralTitle().equals(""); } /* set the plural title */ public void setPluralTitle(String v) { this.setFieldValue(FLD_pluralTitle, StringTools.trim(v)); } // Bean access fields above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ /* overridden to set default values */ public void setCreationDefaultValues() { this.setDescription("String"); this.setSingularTitle("singular"); this.setPluralTitle("plural"); // super.setRuntimeDefaultValues(); } // ------------------------------------------------------------------------ /* return the AccountID/StringID */ public String toString() { return this.getAccountID() + "/" + this.getStringID(); } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ public static boolean exists(String acctID, String strID) throws DBException // if error occurs while testing existance { if ((acctID != null) && (strID != null)) { AccountString.Key strKey = new AccountString.Key(acctID, strID); return strKey.exists(); } return false; } // ------------------------------------------------------------------------ /* 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(); } // ------------------------------------------------------------------------ /* 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 } } /* get the singular/plural strings in an array that can be used directly by "i18n.getStr...(...)" */ public static String[] getStringsArray(Account account, String strID, String dft[]) { /* get values */ try { AccountString str = AccountString.getAccountString(account, strID); if (str != null) { String s = str.getSingularTitle(); String p = str.getPluralTitle(); if ((dft != null) && (dft.length >= 2)) { if (s.equals("")) { s = dft[0]; } if (p.equals("")) { p = dft[1]; } } return new String[] { s, // singular p // plural }; } } catch (DBException dbe) { // ignore } /* return default */ return dft; // not found } // ------------------------------------------------------------------------ /* get account string */ // 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; } } /* create string */ public static AccountString createNewAccountString(Account account, String strID) throws DBException { if ((account != null) && (strID != null) && !strID.equals("")) { AccountString str = AccountString.getAccountString(account, strID, true); // does not return null str.save(); return str; } else { throw new DBException("Invalid Account/StringID specified"); } } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Main admin entry point below private static final String ARG_ACCOUNT[] = new String[] {"account", "acct"}; private static final String ARG_STRING[] = new String[] {"string", "str"}; private static final String ARG_CREATE[] = new String[] {"create"}; private static final String ARG_EDIT[] = new String[] {"edit", "ed"}; private static final String ARG_DELETE[] = new String[] {"delete"}; private static String _fmtStrID(String acctID, String strID) { return acctID + "/" + strID; } private static void usage() { Print.logInfo("Usage:"); Print.logInfo(" java ... " + AccountString.class.getName() + " {options}"); Print.logInfo("Common Options:"); Print.logInfo(" -account=<id> Acount ID which owns AccountString"); Print.logInfo(" -string=<id> String ID to create/edit"); Print.logInfo(" -create Create a new AccountString"); Print.logInfo(" -edit Edit an existing (or newly created) AccountString"); Print.logInfo(" -delete Delete specified AccountString"); System.exit(1); } 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(); } } // ------------------------------------------------------------------------ }
public class StatusCode extends DeviceRecord<StatusCode> { // ------------------------------------------------------------------------ public static final String ALL_DEVICES = "*"; // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // SQL table definition below /* table name */ public static final String _TABLE_NAME = "StatusCode"; public static String TABLE_NAME() { return DBProvider.translateTableName(_TABLE_NAME); } /* field definition */ public static final String FLD_statusCode = "statusCode"; public static final String FLD_statusName = "statusName"; public static final String FLD_iconSelector = "iconSelector"; public static final String FLD_iconName = "iconName"; private static DBField FieldInfo[] = { // StatusCode fields newField_accountID(true), newField_deviceID(true), new DBField( FLD_statusCode, Integer.TYPE, DBField.TYPE_UINT32, "Status Code", "key=true editor=statusCode format=X2"), new DBField(FLD_statusName, String.class, DBField.TYPE_STRING(18), "Status Name", "edit=2"), new DBField( FLD_iconSelector, String.class, DBField.TYPE_STRING(128), "Icon Selector", "edit=2 editor=ruleSelector"), new DBField(FLD_iconName, String.class, DBField.TYPE_STRING(24), "Icon Name", "edit=2"), // Common fields newField_description(), newField_lastUpdateTime(), newField_creationTime(), }; /* key class */ public static class Key extends DeviceKey<StatusCode> { public Key() { super(); } public Key(String accountId, int statusCode) { this(accountId, ALL_DEVICES, statusCode); } public Key(String accountId, String deviceId, int statusCode) { super.setFieldValue(FLD_accountID, ((accountId != null) ? accountId.toLowerCase() : "")); super.setFieldValue(FLD_deviceID, ((deviceId != null) ? deviceId.toLowerCase() : "")); super.setFieldValue(FLD_statusCode, statusCode); } public DBFactory<StatusCode> getFactory() { return StatusCode.getFactory(); } } /* factory constructor */ private static DBFactory<StatusCode> factory = null; 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; } /* Bean instance */ public StatusCode() { super(); } /* database record */ public StatusCode(StatusCode.Key key) { super(key); } // ------------------------------------------------------------------------ /* table description */ public static String getTableDescription(Locale loc) { I18N i18n = I18N.getI18N(StatusCode.class, loc); return i18n.getString( "StatusCode.description", "This table defines " + "Device specific StatusCode descriptions."); } // SQL table definition above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Bean access fields below public int getStatusCode() { Integer v = (Integer) this.getFieldValue(FLD_statusCode); return (v != null) ? v.intValue() : 0; } public void setStatusCode(int v) { this.setFieldValue(FLD_statusCode, v); } // ------------------------------------------------------------------------ public String getStatusName() { String v = (String) this.getFieldValue(FLD_statusName); return StringTools.trim(v); } public void setStatusName(String v) { this.setFieldValue(FLD_statusName, StringTools.trim(v)); } // ------------------------------------------------------------------------ public String getIconSelector() { String v = (String) this.getFieldValue(FLD_iconSelector); return StringTools.trim(v); } public void setIconSelector(String v) { this.setFieldValue(FLD_iconSelector, StringTools.trim(v)); } // ------------------------------------------------------------------------ public String getIconName() { String v = (String) this.getFieldValue(FLD_iconName); return StringTools.trim(v); } public void setIconName(String v) { this.setFieldValue(FLD_iconName, StringTools.trim(v)); } // Bean access fields above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ public String toString() { StringBuffer sb = new StringBuffer(); sb.append(this.getAccountID()); sb.append("/"); sb.append(this.getDeviceID()); sb.append(" "); sb.append(this.getStatusCode()); sb.append("["); sb.append(this.getDescription()); sb.append("]"); return sb.toString(); } // ------------------------------------------------------------------------ /* 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 StatusCode */ public static StatusCode findStatusCode(String accountID, String deviceID, int statusCode) { /* check account status codes */ if (!StringTools.isBlank(accountID)) { // first, try account/device if (!StringTools.isBlank(deviceID)) { try { StatusCode.Key codeKey = new StatusCode.Key(accountID, deviceID, statusCode); if (codeKey.exists()) { // may throw DBException StatusCode code = codeKey.getDBRecord(true); if (code != null) { // should not be null return code; } } } catch (DBException dbe) { // ignore error } } // next, try just the account try { StatusCode.Key codeKey = new StatusCode.Key(accountID, statusCode); if (codeKey.exists()) { // may throw DBException StatusCode code = codeKey.getDBRecord(true); if (code != null) { // should not be null return code; } } } catch (DBException dbe) { // ignore error } } /* check global status codes */ String sysAdmin = AccountRecord.getSystemAdminAccountID(); if (!StringTools.isBlank(sysAdmin)) { try { StatusCode.Key codeKey = new StatusCode.Key(sysAdmin, statusCode); if (codeKey.exists()) { // may throw DBException StatusCode code = codeKey.getDBRecord(true); if (code != null) { // should not be null return code; } } } catch (DBException dbe) { // ignore error } } /* icon selector not found */ return null; } // ------------------------------------------------------------------------ /* Return status code description */ public static String getDescription( Device device, int statusCode, BasicPrivateLabel bpl, String dftDesc) { /* device code */ if (device != null) { StatusCode code = device.getStatusCode(statusCode); if (code != null) { return code.getDescription(); } } /* default */ if (!StringTools.isBlank(dftDesc)) { return dftDesc; } else { return StatusCodes.GetDescription(statusCode, bpl); } } /* Return status code description (used by RuleInfo, RequestProperties) */ public static String getDescription( String accountID, int statusCode, BasicPrivateLabel pl, String dftDesc) { /* custom code (record) */ StatusCode code = StatusCode.findStatusCode(accountID, null, statusCode); if (code != null) { return code.getDescription(); } /* default */ if (!StringTools.isBlank(dftDesc)) { return dftDesc; } else { return StatusCodes.GetDescription(statusCode, pl); } } // ------------------------------------------------------------------------ /* return icon selector */ public static String getIconSelector(Device device, int statusCode, BasicPrivateLabel pl) { /* device code */ if (device != null) { StatusCode code = device.getStatusCode(statusCode); if (code != null) { return code.getIconSelector(); } } /* default */ return ""; } // ------------------------------------------------------------------------ /* return icon name */ public static String getIconName(Device device, int statusCode, BasicPrivateLabel pl) { /* device code */ if (device != null) { StatusCode code = device.getStatusCode(statusCode); if (code != null) { return code.getIconName(); } } /* default */ return StatusCodes.GetIconName(statusCode, pl); } // ------------------------------------------------------------------------ /* return true if StatusCode exists */ public static boolean exists(String accountID, String deviceID, int code) throws DBException // if error occurs while testing existance { if ((accountID != null) && (deviceID != null)) { StatusCode.Key scKey = new StatusCode.Key(accountID, deviceID, code); return scKey.exists(); } return false; } // ------------------------------------------------------------------------ /* Return specified StatusCode (or null if non-existant) */ public static StatusCode getStatusCode(String accountID, String deviceID, int code) throws DBException { return StatusCode._getStatusCode(accountID, null, deviceID, code, false); } /* Return specified StatusCode (or null if non-existant) */ public static StatusCode getStatusCode(Account account, String deviceID, int code) throws DBException { return StatusCode._getStatusCode(null, account, deviceID, code, false); } /* Return specified StatusCode, create if specified */ public static StatusCode getStatusCode( Account account, String deviceID, int code, boolean createOK) throws DBException { return StatusCode._getStatusCode(null, account, deviceID, code, createOK); } /* 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; } } // ------------------------------------------------------------------------ /* create a new StatusCode */ public static StatusCode createNewStatusCode(Account account, String deviceID, int code) throws DBException { /* invalid account */ if (account == null) { throw new DBException("Invalid/Null Account specified"); } /* invalid code */ if ((code < 0) || (code > 0xFFFF)) { throw new DBException("Invalid StatusCode specified"); } /* default to 'ALL' devices */ if (StringTools.isBlank(deviceID)) { deviceID = ALL_DEVICES; } /* create status code */ StatusCode sc = StatusCode.getStatusCode(account, deviceID, code, true); // does not return null sc.save(); return sc; } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ /* return status codes for account/device */ public static int[] getStatusCodes(String accountID, String deviceID) throws DBException { /* account-id specified? */ if (StringTools.isBlank(accountID)) { return new int[0]; } /* device-id specified? */ if (StringTools.isBlank(deviceID)) { deviceID = ALL_DEVICES; } /* select */ // DBSelect: SELECT statucCode FROM StatusCode WHERE (accountID='acct') AND (deviceID='*') ORDER // BY statucCode DBSelect<StatusCode> dsel = new DBSelect<StatusCode>(StatusCode.getFactory()); dsel.setSelectedFields(StatusCode.FLD_statusCode); DBWhere dwh = dsel.createDBWhere(); dsel.setWhere( dwh.WHERE_( dwh.AND( dwh.EQ(StatusCode.FLD_accountID, accountID), dwh.EQ(StatusCode.FLD_deviceID, deviceID)))); dsel.setOrderByFields(StatusCode.FLD_statusCode); /* get list */ java.util.List<Integer> codeList = new Vector<Integer>(); Statement stmt = null; ResultSet rs = null; try { stmt = DBConnection.getDefaultConnection().execute(dsel.toString()); rs = stmt.getResultSet(); while (rs.next()) { int code = rs.getInt(StatusCode.FLD_statusCode); codeList.add(new Integer(code)); } } catch (SQLException sqe) { throw new DBException("Getting StatusCode List", sqe); } finally { if (rs != null) { try { rs.close(); } catch (Throwable t) { } } if (stmt != null) { try { stmt.close(); } catch (Throwable t) { } } } /* return array of status codes */ int codeListInt[] = new int[codeList.size()]; for (int i = 0; i < codeListInt.length; i++) { codeListInt[i] = codeList.get(i).intValue(); } return codeListInt; } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Main admin entry point below private static final String ARG_ACCOUNT[] = new String[] {"account", "acct"}; private static final String ARG_DEVICE[] = new String[] {"device", "dev"}; private static final String ARG_CODE[] = new String[] {"status", "code", "ecode"}; private static final String ARG_ECODE[] = new String[] {"ecode"}; private static final String ARG_DELETE[] = new String[] {"delete"}; private static final String ARG_CREATE[] = new String[] {"create"}; private static final String ARG_EDIT[] = new String[] {"edit", "ed"}; private static final String ARG_LIST[] = new String[] {"list"}; private static void usage() { Print.logInfo("Usage:"); Print.logInfo(" java ... " + StatusCode.class.getName() + " {options}"); Print.logInfo("Options:"); Print.logInfo(" -account=<id> Account ID owning StatusCode"); Print.logInfo(" -device=<id> Device ID owning StatusCode (use '/' for ALL)"); Print.logInfo(" -code=<id> StatusCode to create/delete/edit"); Print.logInfo(" -create Create a new StatusCode"); Print.logInfo(" -edit To edit an existing StatusCode"); Print.logInfo(" -delete Delete specified StatusCode"); System.exit(1); } 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 class RoleAcl extends RoleRecord<RoleAcl> { // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // SQL table definition below /* table name */ public static final String _TABLE_NAME = "RoleAcl"; public static String TABLE_NAME() { return DBProvider.translateTableName(_TABLE_NAME); } /* field definition */ public static final String FLD_aclID = "aclID"; public static final String FLD_accessLevel = "accessLevel"; private static DBField FieldInfo[] = { // RoleAcl fields newField_accountID(true), newField_roleID(true), new DBField(FLD_aclID, String.class, DBField.TYPE_STRING(64), "ACL ID", "key=true"), new DBField( FLD_accessLevel, Integer.TYPE, DBField.TYPE_UINT16, "Access Level", "edit=2 enum=AclEntry$AccessLevel"), // Common fields newField_description(), newField_lastUpdateTime(), newField_creationTime(), }; /* key class */ public static class Key extends RoleKey<RoleAcl> { public Key() { super(); } public Key(String acctId, String roleId, String aclId) { super.setFieldValue(FLD_accountID, ((acctId != null) ? acctId.toLowerCase() : "")); super.setFieldValue(FLD_roleID, ((roleId != null) ? roleId.toLowerCase() : "")); super.setFieldValue(FLD_aclID, ((aclId != null) ? aclId.toLowerCase() : "")); } public DBFactory<RoleAcl> getFactory() { return RoleAcl.getFactory(); } } /* factory constructor */ private static DBFactory<RoleAcl> factory = null; 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; } /* Bean instance */ public RoleAcl() { super(); } /* database record */ public RoleAcl(RoleAcl.Key key) { super(key); } // ------------------------------------------------------------------------ /* table description */ public static String getTableDescription(Locale loc) { I18N i18n = I18N.getI18N(RoleAcl.class, loc); return i18n.getString( "RoleAcl.description", "This table defines " + "Role specific Access Control permissions."); } // SQL table definition above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Bean access fields below public String getAclID() { String v = (String) this.getFieldValue(FLD_aclID); return StringTools.trim(v); } private void setAclID(String v) { this.setFieldValue(FLD_aclID, StringTools.trim(v)); } // ------------------------------------------------------------------------ public int getAccessLevel() { Integer v = (Integer) this.getFieldValue(FLD_accessLevel); return (v != null) ? v.intValue() : 0; } public void setAccessLevel(int v) { this.setFieldValue(FLD_accessLevel, EnumTools.getValueOf(AccessLevel.class, v).getIntValue()); } public void setAccessLevel(String v) { this.setFieldValue(FLD_accessLevel, EnumTools.getValueOf(AccessLevel.class, v).getIntValue()); } public boolean hasReadAccess() { return AclEntry.okRead(this.getAccessLevel()); } public boolean hasWriteAccess() { return AclEntry.okWrite(this.getAccessLevel()); } public boolean hasAllAccess() { // This can be implied to mean 'read all' access if no writing is allowed for this ACL return AclEntry.okAll(this.getAccessLevel()); } // Bean access fields above // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ public String toString() { return this.getAccountID() + "/" + this.getRoleID() + "/" + this.getAclID(); } // ------------------------------------------------------------------------ /* overridden to set default values */ public void setCreationDefaultValues() { // super.setRuntimeDefaultValues(); } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // The following is an optimization for holding the Role record while // processing this RoleAcl. Use with caution. // ------------------------------------------------------------------------ /* return true if the specified role ACL exists */ public static boolean exists(String acctID, String roleID, String aclID) throws DBException // if error occurs while testing existance { if ((acctID != null) && (roleID != null) && (aclID != null)) { RoleAcl.Key aclKey = new RoleAcl.Key(acctID, roleID, aclID); return aclKey.exists(); } return false; } // ------------------------------------------------------------------------ /* return Role access level */ public static AccessLevel getAccessLevel(RoleAcl ra) { return (ra != null) ? EnumTools.getValueOf(AccessLevel.class, ra.getAccessLevel()) : EnumTools.getDefault(AccessLevel.class); } /* return Role access level */ public static AccessLevel getAccessLevel(Role role, String aclId, AccessLevel dftAccess) { if (role == null) { return dftAccess; } else if (StringTools.isBlank(aclId)) { return dftAccess; } else { try { RoleAcl roleAcl = RoleAcl.getRoleAcl(role, aclId); // may throw DBException if (roleAcl != null) { return RoleAcl.getAccessLevel(roleAcl); } else { return dftAccess; } } catch (DBException dbe) { // error occurred return AccessLevel.NONE; } } } /* set Role access level */ public static void setAccessLevel(Role role, String aclId, AccessLevel level) throws DBException { /* role specified? */ if (role == null) { throw new DBException("Role not specified."); } String acctId = role.getAccountID(); String roleId = role.getRoleID(); /* acl-id specified? */ if (StringTools.isBlank(aclId)) { throw new DBException("Acl-ID not specified."); } /* get/create role */ RoleAcl roleAcl = null; RoleAcl.Key aclKey = new RoleAcl.Key(acctId, roleId, aclId); if (aclKey.exists()) { // may throw DBException roleAcl = RoleAcl.getRoleAcl(role, aclId); // may throw DBException } else { roleAcl = aclKey.getDBRecord(); roleAcl.setRole(role); } /* set access level */ int levelInt = (level != null) ? level.getIntValue() : AccessLevel.NONE.getIntValue(); roleAcl.setAccessLevel(levelInt); /* save */ roleAcl.save(); // may throw DBException } /* set Role access level */ public static boolean deleteAccessLevel(Role role, String aclId) throws DBException { /* role specified? */ if (role == null) { return false; // quietly ignore } String acctId = role.getAccountID(); String roleId = role.getRoleID(); /* acl-id specified? */ if (StringTools.isBlank(aclId)) { return false; // quietly ignore } /* already deleted? */ boolean aclExists = RoleAcl.exists(acctId, roleId, aclId); if (!aclExists) { return false; } /* delete */ RoleAcl.Key aclKey = new RoleAcl.Key(acctId, roleId, aclId); aclKey.delete(true); // also delete dependencies return true; } // ------------------------------------------------------------------------ /* Return specified role */ public static RoleAcl getRoleAcl(Role role, String aclId) throws DBException { if ((role != null) && (aclId != null)) { RoleAcl.Key aclKey = new RoleAcl.Key(role.getAccountID(), role.getRoleID(), aclId); if (aclKey.exists()) { RoleAcl roleAcl = aclKey.getDBRecord(true); roleAcl.setRole(role); return roleAcl; } else { return null; } } else { throw new DBException("Role or AclID is null"); } } /* Return specified role ACL, create if specified */ public static RoleAcl getRoleAcl(Role role, String aclId, boolean create) throws DBException { // does not return null /* role specified? */ if (role == null) { throw new DBNotFoundException("Role not specified."); } String acctId = role.getAccountID(); String roleId = role.getRoleID(); /* acl-id specified? */ if (StringTools.isBlank(aclId)) { throw new DBNotFoundException("Acl-ID not specified."); } /* get/create role */ RoleAcl roleAcl = null; RoleAcl.Key aclKey = new RoleAcl.Key(acctId, roleId, aclId); if (!aclKey.exists()) { // may throw DBException if (create) { roleAcl = aclKey.getDBRecord(); roleAcl.setRole(role); roleAcl.setCreationDefaultValues(); return roleAcl; // not yet saved! } else { throw new DBNotFoundException("Acl-ID does not exists '" + aclKey + "'"); } } else if (create) { // we've been asked to create the Acl, and it already exists throw new DBAlreadyExistsException("Acl-ID already exists '" + aclKey + "'"); } else { roleAcl = RoleAcl.getRoleAcl(role, aclId); // may throw DBException if (roleAcl == null) { throw new DBException("Unable to read existing Role-ID '" + aclKey + "'"); } return roleAcl; } } /* Create specified role. Return null if acl already exists */ public static RoleAcl createNewRoleAcl(Role role, String aclID) throws DBException { RoleAcl roleAcl = RoleAcl.getRoleAcl(role, aclID, true); if (roleAcl != null) { roleAcl.save(); } return roleAcl; } // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // ------------------------------------------------------------------------ // Main admin entry point below private static final String ARG_ACCOUNT[] = new String[] {"account", "acct"}; private static final String ARG_ROLE[] = new String[] {"role"}; private static final String ARG_LIST[] = new String[] {"list"}; private static final String ARG_ACL[] = new String[] {"acl"}; private static final String ARG_SET[] = new String[] {"set"}; private static final String ARG_CREATE[] = new String[] {"create", "cr"}; private static final String ARG_EDIT[] = new String[] {"edit", "ed"}; private static final String ARG_DELETE[] = new String[] {"delete", "purge"}; private static void usage() { Print.logInfo("Usage:"); Print.logInfo(" java ... " + RoleAcl.class.getName() + " {options}"); Print.logInfo("Common Options:"); Print.logInfo(" -account=<id> Acount ID which owns Role"); Print.logInfo(" -role=<id> Role ID which owns RoleAcl"); Print.logInfo(" -list List Acls for Role"); Print.logInfo(" -acl=<id> Role ID to create/edit"); Print.logInfo(" -set=<val> RoleAcl value (create if necessary)"); Print.logInfo(" -create Create a new RoleAcl"); Print.logInfo(" -edit Edit an existing (or newly created) RoleAcl"); Print.logInfo(" -delete Delete specified RoleAcl"); System.exit(1); } 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(); } } // ------------------------------------------------------------------------ }