/** ** Main entery point for debugging/testing */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
Print.setAllOutputToStdout(true);
Print.setEncoding(ENCODING_UTF8);
String accountID = RTConfig.getString(ARG_ACCOUNT, "demo");
GoogleGeocodeV2 gn = new GoogleGeocodeV2("google", null, null);
/* reverse geocode */
if (RTConfig.hasProperty(ARG_REVGEOCODE)) {
GeoPoint gp = new GeoPoint(RTConfig.getString(ARG_REVGEOCODE, null));
if (!gp.isValid()) {
Print.logInfo("Invalid GeoPoint specified");
System.exit(1);
}
Print.logInfo("Reverse-Geocoding GeoPoint: " + gp);
Print.sysPrintln(
"RevGeocode = " + gn.getReverseGeocode(gp, null /*localeStr*/, false /*cache*/));
// Note: Even though the values are printed in UTF-8 character encoding, the
// characters may not appear to be property displayed if the console display
// does not support UTF-8.
System.exit(0);
}
/* no options */
Print.sysPrintln("No options specified");
System.exit(1);
}
/** ** Main client thread loop */
public void run() {
this.setRunStatus(THREAD_RUNNING);
this.threadStarted();
try {
this.openSocket();
this.inputThread = new InputThread(this.socket, this.readTimeout, this.ioThreadLock);
this.outputThread = new OutputThread(this.socket, this.ioThreadLock);
this.inputThread.start();
this.outputThread.start();
synchronized (this.ioThreadLock) {
while (this.inputThread.isRunning() || this.outputThread.isRunning()) {
try {
this.ioThreadLock.wait();
} catch (Throwable t) {
}
}
}
} catch (NoRouteToHostException nrthe) {
Print.logInfo("Client:ControlThread - Unable to reach " + this.host + ":" + this.port);
nrthe.printStackTrace();
} catch (Throwable t) {
Print.logInfo("Client:ControlThread - " + t);
t.printStackTrace();
} finally {
this.closeSocket();
}
this.setRunStatus(THREAD_STOPPED);
this.threadStopped();
}
/**
* ** Returns true if the parent records in their respective parent tables exist. ** @return True
* if the parent records exist.
*/
public boolean parentsExist() throws DBException {
DBFactory<gDBR> dbFact = this.getFactory();
DBFieldValues myFldVals = this.getFieldValues();
java.util.List<String> parentList = dbFact.getParentTables();
for (String parentTable : parentList) {
/* get parent table DBFactory */
Print.logInfo("[%s] Parent table: %s", this.getTableName(), parentTable);
DBFactory parentFact = DBFactory.getFactoryByName(parentTable);
if (parentFact == null) {
Print.logError("Unexpected error finding parent table: " + parentTable);
return false;
}
/* create parent record key with fields from this key */
DBRecordKey parentKey = parentFact.createKey(); // an empty key
DBField parentKeyFlds[] = parentFact.getKeyFields();
for (DBField pkf : parentKeyFlds) {
String pfn = pkf.getName();
/* get this DBField */
DBField myKeyFld = this.getField(pfn);
if (myKeyFld == null) {
Print.logError("Unexpected error finding field: [" + this.getTableName() + "] " + pfn);
return false;
}
/* get parent key field value */
Object pkv = myFldVals.getFieldValue(pfn);
if (pkv == null) {
Print.logError("Unexpected error finding parent field: [" + parentTable + "] " + pfn);
return false;
}
if (myKeyFld.isDefaultValue(pkv)) {
Print.logInfo("This key contains a global value, skipping parent check: " + parentTable);
parentKey = null;
break;
}
parentKey.setFieldValue(pfn, pkv);
}
/* check parent existence */
if ((parentKey != null) && !parentKey.exists()) {
Print.logError("Parent record does not exist: [" + parentTable + "] " + parentKey);
return false;
}
}
return true;
}
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);
}
private static void usage() {
Print.logInfo("Usage:");
Print.logInfo(" java ... " + ClientSocketThread.class.getName() + " {options}");
Print.logInfo("'Send' Options:");
Print.logInfo(" -host=<host> The destination host");
Print.logInfo(" -port=<port> The destination port");
Print.logInfo(" -send=<data> The data to send (prefix with '0x' for hex data)");
Print.logInfo("'Receive' Options (not yet implemented):");
Print.logInfo(" -port=<port> The port on which to listen for incoming data");
Print.logInfo(" -recv Set to 'receive' mode");
System.exit(1);
}
protected String getStringProperty(Device device, String key, String dft) {
DCServerConfig dcs =
(device != null) ? DCServerFactory.getServerConfig(device.getDeviceCode()) : null;
String prop = null;
if (dcs != null) {
prop = dcs.getStringProperty(key, dft);
Print.logInfo("DCServerConfig property '" + key + "' ==> " + prop);
if (StringTools.isBlank(prop) && RTConfig.hasProperty(key)) {
Print.logInfo("(RTConfig property '" + key + "' ==> " + RTConfig.getString(key, "") + ")");
}
} else {
prop = RTConfig.getString(key, dft);
Print.logInfo("RTConfig property '" + key + "' ==> " + prop);
}
return prop;
}
protected DCServerFactory.ResultCode sendEmail(
String frEmail, String toEmail, String subj, String body) {
if (StringTools.isBlank(frEmail)) {
Print.logError("'From' Email address not specified");
return DCServerFactory.ResultCode.TRANSMIT_FAIL;
} else if (StringTools.isBlank(toEmail) || !CommandPacketHandler.validateAddress(toEmail)) {
Print.logError("'To' SMS Email address invalid, or not specified");
return DCServerFactory.ResultCode.TRANSMIT_FAIL;
} else if (StringTools.isBlank(subj) && StringTools.isBlank(body)) {
Print.logError("Command string not specified");
return DCServerFactory.ResultCode.INVALID_ARG;
} else {
try {
Print.logInfo("SMS email: to <" + toEmail + ">");
Print.logDebug(" From : " + frEmail);
Print.logDebug(" To : " + toEmail);
Print.logDebug(" Subject: " + subj);
Print.logDebug(" Message: " + body);
SendMail.send(frEmail, toEmail, null, null, subj, body, null);
return DCServerFactory.ResultCode.SUCCESS;
} catch (Throwable t) { // NoClassDefFoundException, ClassNotFoundException
// this will fail if JavaMail support for SendMail is not available.
Print.logWarn("SendMail error: " + t);
return DCServerFactory.ResultCode.TRANSMIT_FAIL;
}
}
}
/* start UDP listener */
private ServerSocketThread _startUDP(int port) throws Throwable {
ServerSocketThread sst = null;
/* create server socket */
try {
sst = new ServerSocketThread(ServerSocketThread.createDatagramSocket(port));
} catch (Throwable t) { // trap any server exception
Print.logException("ServerSocket error", t);
throw t;
}
/* initialize */
sst.setTextPackets(Constants.ASCII_PACKETS);
sst.setBackspaceChar(null); // no backspaces allowed
sst.setLineTerminatorChar(Constants.ASCII_LINE_TERMINATOR);
sst.setIgnoreChar(Constants.ASCII_IGNORE_CHARS);
sst.setMaximumPacketLength(Constants.MAX_PACKET_LENGTH);
sst.setMinimumPacketLength(Constants.MIN_PACKET_LENGTH);
sst.setIdleTimeout(TrackServer.udpTimeout_idle);
sst.setPacketTimeout(TrackServer.udpTimeout_packet);
sst.setSessionTimeout(TrackServer.udpTimeout_session);
sst.setTerminateOnTimeout(Constants.TERMINATE_ON_TIMEOUT);
sst.setClientPacketHandlerClass(TrackClientPacketHandler.class);
/* start thread */
Print.logInfo(
"Starting UDP listener thread on port "
+ port
+ " [timeout="
+ sst.getSessionTimeout()
+ "ms] ...");
sst.start();
this.udpThread.add(sst);
return sst;
}
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 void run() {
String command = null;
Print.logInfo("Client:OutputThread started");
while (true) {
/* wait for commands */
synchronized (this.cmdList) {
while ((this.cmdList.size() <= 0) && (getRunStatus() == THREAD_RUNNING)) {
try {
this.cmdList.wait(5000L);
} catch (Throwable t) {
/*ignore*/
}
}
if (getRunStatus() != THREAD_RUNNING) {
break;
}
command = this.cmdList.remove(0).toString();
}
/* send commands */
try {
ClientSocketThread.socketWriteLine(this.socket, command);
} catch (Throwable t) {
Print.logError("Client:OutputThread - " + t);
t.printStackTrace();
break;
}
}
if (getRunStatus() == THREAD_RUNNING) {
Print.logWarn("Client:OutputThread stopped due to error");
} else {
Print.logInfo("Client:OutputThread stopped");
}
synchronized (this.threadLock) {
this.isRunning = false;
Print.logInfo("Client:OutputThread stopped");
this.threadLock.notify();
}
}
/** ** Prints all LocalString keys for this I18N instance */
public void printKeyValues() {
Enumeration e = this.getKeys();
if (e != null) {
for (; e.hasMoreElements(); ) {
String k = (String) e.nextElement();
String v = this.getString(k, "?");
Print.logInfo("Key:" + k + " Value:" + v);
}
}
}
private static void usage() {
Print.logInfo("Usage:");
Print.logInfo(" java ... " + URIArg.class.getName() + " {options}");
Print.logInfo("Options:");
Print.logInfo(" -encode=<ASCII> Encode ASCII string to URL argument string");
Print.logInfo(" -decode=<args> Decode URL argument string to ASCII");
Print.logInfo(" -rtpEnc=<url> RTP Encode URL [key = 'rtp']");
Print.logInfo(" -rtpDec=<url> RTP Decode URL [key = 'rtp']");
System.exit(1);
}
/**
* ** Gets the Localized value for the specified key. The default String text is return if ** the
* specified key does not exist ** @param key The LocalStrings key ** @param dft The default
* String text to return if the LocalStrings key does not exist ** @param args An array of
* replacement fields ** @return The Localized String text
*/
public String getString(String key, String dft, Object args[]) {
String val = this.getString(key, dft);
if ((args != null) && (args.length > 0) && (val != null)) {
try {
MessageFormat mf = new MessageFormat(val);
mf.setLocale(this.locale);
StringBuffer sb = mf.format(args, new StringBuffer(), null);
return I18N.decodeNewLine(sb).toString();
} catch (Throwable th) {
Print.logInfo("Exception: " + key + " ==> " + val);
}
}
return I18N.decodeNewLine(val);
}
/**
* ** Constructor ** @param pkgName The resource package name ** @param loc The Locale resource
* from with the localized text is loaded
*/
private I18N(String pkgName, Locale loc) {
String bundleName = null;
try {
this.locale = I18N.getLocale(loc);
bundleName =
((pkgName == null) || pkgName.equals("")) ? LOCAL_STRINGS : (pkgName + _LOCAL_STRINGS);
this.resBundle = ResourceBundle.getBundle(bundleName, this.locale);
// Print.logInfo("Found bundle: " + bundleName);
} catch (Throwable th) {
// MissingResourceException
if (loc != null) {
// quietly ignore this exception if (loc == null)
Print.logInfo("Bundle not found: " + bundleName + " [" + th);
}
this.resBundle = null;
}
}
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
long ts = DateTime.getCurrentTimeSec();
double C = -5.6;
TemperatureSet TSList[] = new TemperatureSet[3];
for (int s = 0; s < TSList.length; s++) {
TemperatureSet TS = new TemperatureSet();
for (int i = 0; i < 10; i++) {
long tempTS = ts + (12345L * (i + 1) * (s + 1));
double tempC = C + (2.3 * i) + (1.1 * s);
Print.logInfo(s + ":" + i + "] Adding " + tempTS + ", " + tempC);
TS.addTemperature(tempTS, tempC);
}
TSList[s] = TS;
}
String t = TemperatureSet.CreateGoogleDataTableJavaScript(false, TSList);
Print.sysPrintln(t);
}
/* start TCP listener */
private void _startTCP(int port) throws Throwable {
ServerSocketThread sst = null;
/* create server socket */
try {
sst = new ServerSocketThread(port);
} catch (Throwable t) { // trap any server exception
Print.logException("ServerSocket error", t);
throw t;
}
/* initialize */
sst.setTextPackets(Constants.ASCII_PACKETS);
sst.setBackspaceChar(null); // no backspaces allowed
sst.setLineTerminatorChar(Constants.ASCII_LINE_TERMINATOR);
sst.setIgnoreChar(Constants.ASCII_IGNORE_CHARS);
sst.setMaximumPacketLength(Constants.MAX_PACKET_LENGTH);
sst.setMinimumPacketLength(Constants.MIN_PACKET_LENGTH);
sst.setIdleTimeout(TrackServer.tcpTimeout_idle); // time between packets
sst.setPacketTimeout(
TrackServer.tcpTimeout_packet); // time from start of packet to packet completion
sst.setSessionTimeout(TrackServer.tcpTimeout_session); // time for entire session
sst.setTerminateOnTimeout(Constants.TERMINATE_ON_TIMEOUT);
sst.setClientPacketHandlerClass(TrackClientPacketHandler.class);
sst.setLingerTimeoutSec(Constants.LINGER_ON_CLOSE_SEC);
/* start thread */
Print.logInfo(
"Starting TCP listener thread on port "
+ port
+ " [timeout="
+ sst.getSessionTimeout()
+ "ms] ...");
sst.start();
this.tcpThread.add(sst);
}
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 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 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 boolean insertEventData() {
/* valid device? */
if (this.device == null) {
return false;
}
/* debug message */
if (RTConfig.isDebugMode()) {
Print.logDebug("Inserting EventData ...\n" + this.toString());
}
/* EventData key */
String acctID = this.device.getAccountID();
String devID = this.device.getDeviceID();
long fixtime = this.getTimestamp();
int statusCode = this.getStatusCode();
EventData.Key evKey = new EventData.Key(acctID, devID, fixtime, statusCode);
EventData evdb = evKey.getDBRecord();
/* set EventData field values */
if (USE_EVENTDATA_SETVALUE) {
for (Object fldn : this.fieldValues.getPropertyKeys()) {
if (fldn.equals(EventData.FLD_timestamp)) {
continue; // already set above
} else if (fldn.equals(EventData.FLD_statusCode)) {
continue; // already set above
}
Object fldv = this.fieldValues.getProperty(fldn, null);
if (fldv != null) {
evdb.setValue((String) fldn, fldv); // attempts to use "setter" methods
}
}
} else {
if (this.hasLatitude()) {
evdb.setLatitude(this.getLatitude());
}
if (this.hasLongitude()) {
evdb.setLongitude(this.getLongitude());
}
if (this.hasGpsAge()) {
evdb.setGpsAge(this.getGpsAge());
}
if (this.hasHDOP()) {
evdb.setHDOP(this.getHDOP());
}
if (this.hasSatelliteCount()) {
evdb.setSatelliteCount(this.getSatelliteCount());
}
if (this.hasSpeedKPH()) {
evdb.setSpeedKPH(this.getSpeedKPH());
}
if (this.hasHeading()) {
evdb.setHeading(this.getHeading());
}
if (this.hasAltitude()) {
evdb.setAltitude(this.getAltitude());
}
if (this.hasInputMask()) {
evdb.setInputMask(this.getInputMask());
}
if (this.hasBatteryLevel()) {
evdb.setBatteryLevel(this.getBatteryLevel());
}
if (this.hasSignalStrength()) {
evdb.setSignalStrength(this.getSignalStrength());
}
if (this.hasOdometerKM()) {
evdb.setOdometerKM(this.getOdometerKM());
}
if (this.hasEngineHours()) {
evdb.setEngineHours(this.getEngineHours());
}
if (this.hasPtoHours()) {
evdb.setPtoHours(this.getPtoHours());
}
if (this.hasFuelTotal()) {
evdb.setFuelTotal(this.getFuelTotal());
}
if (this.hasGeozoneID()) {
evdb.setGeozoneID(this.getGeozoneID());
}
}
/* other fields (if available) */
if (this.otherValues != null) {
for (String fldn : this.otherValues.keySet()) {
if (fldn.equals(EventData.FLD_timestamp)) {
continue;
} else if (fldn.equals(EventData.FLD_statusCode)) {
continue;
}
Object fldv = this.otherValues.get(fldn);
if (fldv != null) {
evdb.setValue(fldn, fldv); // attempts to use "setter" methods
}
}
}
/* insert event */
// this will display an error if it was unable to store the event
Print.logInfo(
"Event : [0x"
+ StringTools.toHexString(statusCode, 16)
+ "] "
+ StatusCodes.GetDescription(statusCode, null));
this.device.insertEventData(
evdb); // FLD_lastValidLatitude,FLD_lastValidLongitude,FLD_lastGPSTimestamp,FLD_lastOdometerKM
this.eventTotalCount++;
return true;
}
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();
}
}
