/** ** 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);
}
/* 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;
}
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;
}
}
}
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;
}
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();
}
}
/** ** Main entery point for debugging/testing */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
Print.setAllOutputToStdout(true);
Print.setEncoding(ENCODING_UTF8);
/* host */
String host = RTConfig.getString("host", null);
if (!StringTools.isBlank(host)) {
HOST_PRIMARY = host;
}
/* GeoPoint */
GeoPoint gp = new GeoPoint(RTConfig.getString("gp", null));
if (!gp.isValid()) {
Print.logInfo("Invalid GeoPoint specified");
System.exit(1);
}
Print.logInfo("Reverse-Geocoding GeoPoint: " + gp);
/* Reverse Geocoding */
Nominatim gn = new Nominatim("nominatim", null, RTConfig.getCommandLineProperties());
Print.sysPrintln("RevGeocode = " + gn.getReverseGeocode(gp, null /*localeStr*/));
}
/* 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();
}
}
/**
* ** Returns a ReverseGeocode instance containing address information ** @param gp The GeoPoint
* ** @return The ReverseGeocode instance
*/
private ReverseGeocode getAddressReverseGeocode(GeoPoint gp, String localeStr) {
/* URL */
String url = this.getAddressReverseGeocodeURL(gp);
Print.logInfo("Address URL: " + url);
/* create XML document */
Document xmlDoc = GetXMLDocument(url);
if (xmlDoc == null) {
return null;
}
/* create ReverseGeocode response */
Element reversegeocode = xmlDoc.getDocumentElement();
if (!reversegeocode.getTagName().equalsIgnoreCase(TAG_reversegeocode)) {
return null;
}
/* init */
String address_val = null; // null address
String house_val = null; // house number
String road_val = null; // street name
String city_val = null; // city name
String county_val = null; // county name
String state_val = null; // state/province
String postcode_val = null; // postal code
String country_name_val = null; // country name
String country_code_val = null; // country code
// full address
NodeList resultList = XMLTools.getChildElements(reversegeocode, TAG_result);
for (int r = 0; r < resultList.getLength(); r++) {
Element result = (Element) resultList.item(r);
// String osmType = XMLTools.getAttribute(result, ATTR_osm_type, null, false);
address_val = XMLTools.getNodeText(result, " ", false);
break; // only the first element
}
// address components
NodeList addresspartsList = XMLTools.getChildElements(reversegeocode, TAG_addressparts);
for (int a = 0; (a < addresspartsList.getLength()); a++) {
Element addressparts = (Element) addresspartsList.item(a);
NodeList addresspartsChildren = addressparts.getChildNodes();
for (int ac = 0; ac < addresspartsChildren.getLength(); ac++) {
Node child = addresspartsChildren.item(ac);
if (!(child instanceof Element)) {
continue;
}
Element elem = (Element) child;
String elemName = elem.getNodeName();
if (elemName.equalsIgnoreCase(TAG_house)) {
house_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_tram)) {
// ignore
} else if (elemName.equalsIgnoreCase(TAG_road)) {
road_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_residential)) {
// ignore
} else if (elemName.equalsIgnoreCase(TAG_village)) {
// ignore
} else if (elemName.equalsIgnoreCase(TAG_town)) {
if (StringTools.isBlank(city_val)) {
city_val = XMLTools.getNodeText(elem, " ", false);
}
} else if (elemName.equalsIgnoreCase(TAG_city)) {
city_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_county)) {
county_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_postcode)) {
postcode_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_state)) {
state_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_country)) {
country_name_val = XMLTools.getNodeText(elem, " ", false);
} else if (elemName.equalsIgnoreCase(TAG_country_code)) {
country_code_val = StringTools.trim(XMLTools.getNodeText(elem, " ", false)).toUpperCase();
} else {
// elemName unrecognized
}
}
break; // only the first element
}
/* populate ReverseGeocode instance */
ReverseGeocode rg = new ReverseGeocode();
StringBuffer addr = new StringBuffer();
// house number /road
if (!StringTools.isBlank(house_val)) {
addr.append(house_val);
if (!StringTools.isBlank(road_val)) {
addr.append(" ");
addr.append(road_val);
rg.setStreetAddress(house_val + " " + road_val);
} else {
rg.setStreetAddress(house_val);
}
} else if (!StringTools.isBlank(road_val)) {
addr.append(road_val);
rg.setStreetAddress(road_val);
}
// city/county
if (!StringTools.isBlank(city_val)) {
if (addr.length() > 0) {
addr.append(", ");
}
addr.append(city_val);
rg.setCity(city_val);
}
if (!StringTools.isBlank(county_val)) {
if (StringTools.isBlank(city_val)) {
// "city" not provided, at least include the "county"
if (addr.length() > 0) {
addr.append(", ");
}
addr.append("[").append(county_val).append("]");
}
// rg.setCounty(county_val);
}
// state/province
if (!StringTools.isBlank(state_val)) {
if (addr.length() > 0) {
addr.append(", ");
}
addr.append(state_val);
rg.setStateProvince(state_val);
if (!StringTools.isBlank(postcode_val)) {
addr.append(" ").append(postcode_val);
rg.setPostalCode(postcode_val);
}
} else {
if (!StringTools.isBlank(postcode_val)) {
if (addr.length() > 0) {
addr.append(", ");
}
addr.append(postcode_val);
rg.setPostalCode(postcode_val);
}
}
// country
if (!StringTools.isBlank(country_code_val)) {
if (country_code_val.equalsIgnoreCase("US")) {
// if (addr.length() > 0) { addr.append(", "); }
// addr.append("USA");
} else if (!StringTools.isBlank(country_name_val)) {
if (addr.length() > 0) {
addr.append(", ");
}
addr.append(country_name_val);
} else {
if (addr.length() > 0) {
addr.append(", ");
}
addr.append(country_code_val);
}
rg.setCountryCode(country_code_val);
}
// full address
rg.setFullAddress(addr.toString());
return rg;
}
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();
}
}
