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();
}
}
// ------------------------------------------------------------------------
}
