diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java index 398f14eba..46e35c379 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java @@ -32,4 +32,9 @@ public DbException(String message, Exception cause) { super(message, cause); } + + public DbException(String message) + { + super(message); + } } diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java index d5a931a9d..eeebd1c28 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java @@ -22,7 +22,10 @@ import javax.ws.rs.core.Context; import decodes.cwms.CwmsDatabaseProvider; +import decodes.db.Database; import decodes.db.DatabaseException; +import decodes.db.DatabaseIO; +import decodes.tsdb.TimeSeriesDb; import decodes.util.DecodesSettings; import opendcs.opentsdb.OpenTsdbProvider; import org.opendcs.database.DatabaseService; @@ -81,7 +84,18 @@ final OpenDcsDatabase createDb() { throw new IllegalStateException("Error connecting to the database via JNDI", ex); } -// throw new IllegalStateException("Error connecting to the database via JNDI", e); } } + + DatabaseIO getLegacyDatabase() + { + return createDb().getLegacyDatabase(Database.class).map(Database::getDbIo) + .orElseThrow(() -> new UnsupportedOperationException("Endpoint is unsupported by the OpenDCS REST API.")); + } + + TimeSeriesDb getLegacyTimeseriesDB() + { + return createDb().getLegacyDatabase(TimeSeriesDb.class) + .orElseThrow(() -> new UnsupportedOperationException("Endpoint is unsupported by the OpenDCS REST API.")); + } } diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/PlatformResources.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/PlatformResources.java index 9c7f5d850..42b6fc00f 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/PlatformResources.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/PlatformResources.java @@ -15,12 +15,16 @@ package org.opendcs.odcsapi.res; -import java.sql.SQLException; import java.util.ArrayList; -import java.util.HashMap; -import java.util.logging.Logger; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Vector; import javax.annotation.security.RolesAllowed; +import javax.servlet.http.HttpServletResponse; import javax.ws.rs.Consumes; import javax.ws.rs.DELETE; import javax.ws.rs.GET; @@ -33,19 +37,29 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; +import decodes.db.DatabaseException; +import decodes.db.DatabaseIO; +import decodes.db.Platform; +import decodes.db.PlatformConfig; +import decodes.db.PlatformList; +import decodes.db.PlatformSensor; +import decodes.db.PlatformStatus; +import decodes.db.Site; +import decodes.db.TransportMedium; +import decodes.sql.DbKey; +import decodes.tsdb.DbIoException; +import opendcs.dai.PlatformStatusDAI; import org.opendcs.odcsapi.beans.ApiPlatform; import org.opendcs.odcsapi.beans.ApiPlatformRef; -import org.opendcs.odcsapi.dao.ApiPlatformDAO; +import org.opendcs.odcsapi.beans.ApiPlatformSensor; +import org.opendcs.odcsapi.beans.ApiPlatformStatus; +import org.opendcs.odcsapi.beans.ApiTransportMedium; import org.opendcs.odcsapi.dao.DbException; -import org.opendcs.odcsapi.errorhandling.ErrorCodes; import org.opendcs.odcsapi.errorhandling.WebAppException; -import org.opendcs.odcsapi.hydrojson.DbInterface; import org.opendcs.odcsapi.sec.AuthorizationCheck; -import org.opendcs.odcsapi.util.ApiConstants; -import org.opendcs.odcsapi.util.ApiHttpUtil; @Path("/") -public class PlatformResources +public class PlatformResources extends OpenDcsResource { @Context HttpHeaders httpHeaders; @@ -53,93 +67,350 @@ public class PlatformResources @Path("platformrefs") @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_GUEST}) - public Response gePlatformRefs(@QueryParam("tmtype") String tmtype) - throws DbException, SQLException + public Response getPlatformRefs(@QueryParam("tmtype") String tmtype) + throws DbException { - HashMap ret = new HashMap<>(); - Logger.getLogger(ApiConstants.loggerName).fine("getPlatforms, tmtype=" + tmtype); - try (DbInterface dbi = new DbInterface(); - ApiPlatformDAO platformDAO = new ApiPlatformDAO(dbi)) + Map ret = new LinkedHashMap<>(); + try { - ArrayList platSpecs = platformDAO.getPlatformRefs(tmtype); + // TODO: Add support for filtering by transport media type + DatabaseIO dbio = getLegacyDatabase(); + PlatformList platformList = new PlatformList(); + dbio.readPlatformList(platformList); + List platSpecs = map(platformList); for(ApiPlatformRef ps : platSpecs) ret.put(ps.getName(), ps); + return Response.status(HttpServletResponse.SC_OK).entity(ret).build(); + } + catch (DatabaseException ex) + { + throw new DbException("Unable to retrieve platform list", ex); } - Logger.getLogger(ApiConstants.loggerName).fine("getPlatforms returning " + ret.size() + " objects."); - return ApiHttpUtil.createResponse(ret); } - + + static List map(PlatformList platformList) + { + List ret = new ArrayList<>(); + Iterator platform = platformList.iterator(); + while (platform.hasNext()) + { + ApiPlatformRef ref = new ApiPlatformRef(); + Platform plat = platform.next(); + ref.setName(plat.getDisplayName()); + if (plat.getId() != null) + { + ref.setPlatformId(plat.getId().getValue()); + } + else + { + ref.setPlatformId(DbKey.NullKey.getValue()); + } + ref.setAgency(plat.getAgency()); + ref.setConfig(plat.getConfigName()); + ref.setDescription(plat.getDescription()); + if (plat.getConfig() != null && plat.getConfig().getId() != null) + { + ref.setConfigId(plat.getConfig().getId().getValue()); + } + else + { + ref.setConfigId(DbKey.NullKey.getValue()); + } + if (plat.getSite() != null) + { + ref.setSiteId(plat.getSite().getId().getValue()); + } + else + { + ref.setSiteId(DbKey.NullKey.getValue()); + } + ref.setTransportMedia(plat.getProperties()); + ret.add(ref); + } + return ret; + } + @GET @Path("platform") @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_GUEST}) public Response getPlatform(@QueryParam("platformid") Long platformId) - throws WebAppException, DbException, SQLException + throws WebAppException, DbException { if (platformId == null) - throw new WebAppException(ErrorCodes.MISSING_ID, - "Missing required platformid parameter."); - - Logger.getLogger(ApiConstants.loggerName).fine("getPlatform id=" + platformId); - try (DbInterface dbi = new DbInterface(); - ApiPlatformDAO dao = new ApiPlatformDAO(dbi)) { - return ApiHttpUtil.createResponse(dao.readPlatform(platformId)); + throw new WebAppException(HttpServletResponse.SC_BAD_REQUEST, + "Missing required platformid parameter."); + } + + try + { + DatabaseIO dbio = getLegacyDatabase(); + Platform platform = new Platform(); + platform.setId(DbKey.createDbKey(platformId)); + dbio.readPlatform(platform); + return Response.status(HttpServletResponse.SC_OK).entity(map(platform)).build(); + } + catch (DatabaseException ex) + { + throw new DbException("Unable to retrieve platform", ex); } } - + + static ApiPlatform map(Platform platform) + { + ApiPlatform ret = new ApiPlatform(); + if (platform.getId() != null) + { + ret.setPlatformId(platform.getId().getValue()); + } + else + { + ret.setPlatformId(DbKey.NullKey.getValue()); + } + ret.setAgency(platform.getAgency()); + if (platform.getSite() != null && platform.getSite().getId() != null) + { + ret.setSiteId(platform.getSite().getId().getValue()); + } + ret.setDescription(platform.getDescription()); + ret.setDesignator(platform.getPlatformDesignator()); + if (platform.getConfig() != null && platform.getConfig().getId() != null) + { + ret.setConfigId(platform.getConfig().getId().getValue()); + } + else + { + ret.setConfigId(DbKey.NullKey.getValue()); + } + ret.setProduction(platform.isProduction); + if (platform.getSite() != null && platform.getSite().getId() != null) + { + ret.setSiteId(platform.getSite().getId().getValue()); + } + else + { + ret.setSiteId(DbKey.NullKey.getValue()); + } + ret.setTransportMedia(map(platform.getTransportMedia())); + return ret; + } + + static ArrayList map(Iterator transportMedium) + { + ArrayList transportMedia = new ArrayList<>(); + while (transportMedium.hasNext()) + { + TransportMedium tm = transportMedium.next(); + ApiTransportMedium apiTm = new ApiTransportMedium(); + apiTm.setMediumId(tm.getMediumId()); + apiTm.setMediumType(tm.getMediumType()); + apiTm.setBaud(tm.getBaud()); + apiTm.setAssignedTime(tm.assignedTime); + apiTm.setChannelNum(tm.channelNum); + apiTm.setDataBits(tm.getDataBits()); + apiTm.setTimezone(tm.getTimeZone()); + apiTm.setStopBits(tm.getStopBits()); + apiTm.setParity(String.valueOf(tm.getParity())); + apiTm.setDoLogin(tm.isDoLogin()); + apiTm.setPassword(tm.getPassword()); + apiTm.setUsername(tm.getUsername()); + apiTm.setScriptName(tm.scriptName); + apiTm.setTransportInterval(tm.transmitInterval); + apiTm.setTransportWindow(tm.transmitWindow); + + transportMedia.add(apiTm); + } + return transportMedia; + } + @POST @Path("platform") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_ADMIN, AuthorizationCheck.ODCS_API_USER}) public Response postPlatform(ApiPlatform platform) - throws WebAppException, DbException, SQLException + throws DbException + { + try + { + DatabaseIO dbio = getLegacyDatabase(); + Platform plat = map(platform); + dbio.writePlatform(plat); + return Response.status(HttpServletResponse.SC_OK) + .entity(map(plat)) + .build(); + } + catch (DatabaseException ex) + { + throw new DbException(String.format("Unable to store platform with name: %s", platform.getName()), ex); + } + } + + static Platform map(ApiPlatform platform) throws DatabaseException { - Logger.getLogger(ApiConstants.loggerName) - .fine("post platform received platformId=" + platform.getPlatformId()); - - try (DbInterface dbi = new DbInterface(); - ApiPlatformDAO dao = new ApiPlatformDAO(dbi)) + Platform ret = new Platform(); + if (platform.getPlatformId() != null) { - dao.writePlatform(platform); - return ApiHttpUtil.createResponse(platform); + ret.setId(DbKey.createDbKey(platform.getPlatformId())); } + else + { + ret.setId(DbKey.NullKey); + } + ret.setAgency(platform.getAgency()); + ret.setDescription(platform.getDescription()); + ret.setPlatformDesignator(platform.getDesignator()); + ret.lastModifyTime = platform.getLastModified(); + ret.platformSensors = platMap(platform.getPlatformSensors()); + if (platform.getConfigId() != null) + { + PlatformConfig config = new PlatformConfig(); + config.setId(DbKey.createDbKey(platform.getConfigId())); + ret.setConfig(config); + } + ret.isProduction = platform.isProduction(); + if (platform.getSiteId() != null) + { + Site site = new Site(); + site.setId(DbKey.createDbKey(platform.getSiteId())); + ret.setSite(site); + } + ret.transportMedia = map(platform.getTransportMedia()); + return ret; } - + + static Vector platMap(List platformSensors) throws DatabaseException + { + Vector ret = new Vector<>(); + for (ApiPlatformSensor sensor: platformSensors) + { + PlatformSensor ps = new PlatformSensor(); + ps.sensorNumber = sensor.getSensorNum(); + if (sensor.getActualSiteId() != null) + { + Site site = new Site(); + site.setId(DbKey.createDbKey(sensor.getActualSiteId())); + ps.site = site; + } + ps.setUsgsDdno(sensor.getUsgsDdno()); + Properties props = sensor.getSensorProps(); + for (String name : props.stringPropertyNames()) + { + ps.setProperty(name, props.getProperty(name)); + } + ret.add(ps); + } + return ret; + } + + static Vector map(List transportMedium) + { + Vector ret = new Vector<>(); + for (ApiTransportMedium tm : transportMedium) + { + Platform platform = new Platform(); + TransportMedium t = new TransportMedium(platform); + t.setMediumId(tm.getMediumId()); + t.setMediumType(tm.getMediumType()); + t.setBaud(tm.getBaud()); + t.assignedTime = tm.getAssignedTime(); + t.channelNum = tm.getChannelNum(); + t.setDataBits(tm.getDataBits()); + t.setTimeZone(tm.getTimezone()); + t.setStopBits(tm.getStopBits()); + t.setParity(tm.getParity().charAt(0)); + t.setDoLogin(tm.getDoLogin()); + t.setPassword(tm.getPassword()); + t.setUsername(tm.getUsername()); + t.scriptName = tm.getScriptName(); + t.transmitInterval = tm.getTransportInterval(); + t.transmitWindow = tm.getTransportWindow(); + t.channelNum = tm.getChannelNum(); + t.assignedTime = tm.getAssignedTime(); + ret.add(t); + } + return ret; + } + @DELETE @Path("platform") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_ADMIN, AuthorizationCheck.ODCS_API_USER}) public Response deletePlatform(@QueryParam("platformid") Long platformId) - throws WebAppException, DbException + throws DbException, WebAppException { - Logger.getLogger(ApiConstants.loggerName) - .fine("DELETE platform received id=" + platformId); - - // Use username and password to attempt to connect to the database - try (DbInterface dbi = new DbInterface(); - ApiPlatformDAO platDao = new ApiPlatformDAO(dbi)) + if (platformId == null) { - platDao.deletePlatform(platformId); - return ApiHttpUtil.createResponse("Platform with ID " + platformId + " deleted"); + throw new WebAppException(HttpServletResponse.SC_BAD_REQUEST, + "Missing required platformid parameter."); + } + + try + { + DatabaseIO dbio = getLegacyDatabase(); + Platform plat = new Platform(); + plat.setId(DbKey.createDbKey(platformId)); + dbio.deletePlatform(plat); + return Response.status(HttpServletResponse.SC_OK) + .entity("Platform with ID " + platformId + " deleted") + .build(); + } + catch (DatabaseException ex) + { + throw new DbException(String.format("Unable to delete platform with ID: %s", platformId), ex); } } - + @GET @Path("platformstat") @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_GUEST}) - public Response gePlatformStats(@QueryParam("netlistid") Long netlistId) - throws DbException, SQLException + public Response getPlatformStats(@QueryParam("netlistid") Long netlistId) + throws DbException, WebAppException + { + if (netlistId == null) + { + throw new WebAppException(HttpServletResponse.SC_BAD_REQUEST, + "Missing required netlistid parameter."); + } + + DatabaseIO dbio = getLegacyDatabase(); + try (PlatformStatusDAI dao = dbio.makePlatformStatusDAO()) + { + PlatformStatus status = dao.readPlatformStatus(DbKey.createDbKey(netlistId)); + return Response.status(HttpServletResponse.SC_OK).entity(map(status)).build(); + } + catch (DbIoException ex) + { + throw new DbException(String.format("Unable to retrieve platform status with ID: %s", netlistId), ex); + } + } + + static List map(PlatformStatus status) { - Logger.getLogger(ApiConstants.loggerName).fine("gePlatformStats, netlistid=" + netlistId); - try (DbInterface dbi = new DbInterface(); - ApiPlatformDAO platformDAO = new ApiPlatformDAO(dbi)) + if (status == null) + { + return new ArrayList<>(); + } + List ret = new ArrayList<>(); + ApiPlatformStatus ps = new ApiPlatformStatus(); + if (status.getPlatformId() != null) + { + ps.setPlatformId(status.getPlatformId().getValue()); + } + else { - return ApiHttpUtil.createResponse(platformDAO.getPlatformStatus(netlistId)); + ps.setPlatformId(DbKey.NullKey.getValue()); } + ps.setAnnotation(status.getAnnotation()); + ps.setLastContact(status.getLastContactTime()); + ps.setLastError(status.getLastErrorTime()); + ps.setLastMessage(status.getLastMessageTime()); + ps.setRoutingSpecName(status.getLastRoutingSpecName()); + ret.add(ps); + return ret; } -} +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/PlatformResourcesTest.java b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/PlatformResourcesTest.java new file mode 100644 index 000000000..f0ff7f0ef --- /dev/null +++ b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/PlatformResourcesTest.java @@ -0,0 +1,428 @@ +package org.opendcs.odcsapi.res; + +import java.sql.Date; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Properties; +import java.util.Vector; + +import decodes.db.DecodesScript; +import decodes.db.EquipmentModel; +import decodes.db.Platform; +import decodes.db.PlatformConfig; +import decodes.db.PlatformList; +import decodes.db.PlatformSensor; +import decodes.db.PlatformStatus; +import decodes.db.ScriptSensor; +import decodes.db.Site; +import decodes.db.TransportMedium; +import decodes.sql.DbKey; +import decodes.xml.DecodesScriptParser; +import org.junit.jupiter.api.Test; +import org.opendcs.odcsapi.beans.ApiPlatform; +import org.opendcs.odcsapi.beans.ApiPlatformRef; +import org.opendcs.odcsapi.beans.ApiPlatformSensor; +import org.opendcs.odcsapi.beans.ApiPlatformStatus; +import org.opendcs.odcsapi.beans.ApiTransportMedium; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.opendcs.odcsapi.res.PlatformResources.map; + +final class PlatformResourcesTest +{ + @Test + void testPlatformRefMap() throws Exception + { + DbKey platId1 = DbKey.createDbKey(556774L); + DbKey platId2 = DbKey.createDbKey(557774L); + PlatformList platformList = new PlatformList(); + Platform plat1 = new Platform(); + plat1.setAgency("USGS"); + plat1.setDescription("Platform 1"); + plat1.setPlatformDesignator("Platform Designator"); + plat1.setConfigName("Platform Configuration"); + plat1.setIsComplete(true); + plat1.setId(platId1); + PlatformConfig config = new PlatformConfig(); + config.setId(DbKey.createDbKey(33565L)); + config.configName = "Platform Configuration"; + config.numPlatformsUsing = 11; + config.description = "A configuration for a platform"; + EquipmentModel model = new EquipmentModel(); + model.model = "Model 1"; + model.description = "An equipment model"; + model.setId(DbKey.createDbKey(555584L)); + model.name = "Equipped model"; + model.company = "RMA"; + Properties properties = new Properties(); + properties.setProperty("prop1", "value1"); + model.properties = properties; + config.equipmentModel = model; + Vector scripts = new Vector<>(); + DecodesScript script = new DecodesScript + .DecodesScriptBuilder(new DecodesScriptParser()).platformConfig(config) + .scriptName("Testing Script").build(); + ScriptSensor sensor = new ScriptSensor(script, 22); + script.addScriptSensor(sensor); + scripts.add(script); + config.decodesScripts = scripts; + plat1.setConfig(config); + Platform plat2 = new Platform(); + plat2.setAgency("USBR"); + plat2.setDescription("USBR Platform"); + plat2.setPlatformDesignator("Platform Designator 2"); + plat2.setConfigName("Platform Configuration 2"); + plat2.setIsComplete(true); + plat2.setId(platId2); + PlatformConfig config2 = new PlatformConfig(); + config2.setId(DbKey.createDbKey(34565L)); + config2.configName = plat2.getConfigName(); + config2.numPlatformsUsing = 34; + config2.description = "Configuration data for a platform"; + EquipmentModel model2 = new EquipmentModel(); + model2.model = "Model 2"; + model2.description = "An equipment model"; + model2.setId(DbKey.createDbKey(565584L)); + model2.name = "Equipment model 2"; + model2.company = "GEI"; + Properties properties2 = new Properties(); + properties2.setProperty("prop2", "value2"); + model2.properties = properties2; + config2.equipmentModel = model; + Vector scripts2 = new Vector<>(); + DecodesScript script2 = new DecodesScript + .DecodesScriptBuilder(new DecodesScriptParser()).platformConfig(config2) + .scriptName("Testing Script 2").build(); + ScriptSensor sensor2 = new ScriptSensor(script2, 22); + script2.addScriptSensor(sensor2); + scripts2.add(script2); + config2.decodesScripts = scripts2; + plat2.setConfig(config2); + platformList.add(plat1); + platformList.add(plat2); + + List platRefs = map(platformList); + + assertNotNull(platRefs); + assertFalse(platRefs.isEmpty()); + assertEquals(2, platRefs.size()); + Platform plat1Ref = platformList.getById(platId1); + Platform plat2Ref = platformList.getById(platId2); + assertNotNull(plat1Ref); + assertNotNull(plat2Ref); + + assertEquals(plat1.getAgency(), plat1Ref.getAgency()); + assertEquals(plat1.getDescription(), plat1Ref.getDescription()); + assertEquals(plat1.getPlatformDesignator(), plat1Ref.getPlatformDesignator()); + assertEquals(plat1.getConfigName(), plat1Ref.getConfigName()); + assertEquals(plat1.getId().getValue(), plat1Ref.getId().getValue()); + assertEquals(plat1.getConfig().getId().getValue(), plat1Ref.getConfig().getId().getValue()); + assertEquals(plat1.getConfig().getEquipmentModel().getId().getValue(), plat1Ref.getConfig().getEquipmentModel().getId().getValue()); + assertEquals(plat1.getConfig().getEquipmentModel().getName(), plat1Ref.getConfig().getEquipmentModel().getName()); + assertPlatMatchIterators(plat1.getPlatformSensors(), plat1Ref.getPlatformSensors()); + assertTransportMatch(plat1.getTransportMedia(), plat1Ref.getTransportMedia()); + assertEquals(plat1.getProperties(), plat1Ref.getProperties()); + assertEquals(plat1.getBriefDescription(), plat1Ref.getBriefDescription()); + assertEquals(plat1.getDisplayName(), plat1Ref.getDisplayName()); + if (plat1.getSite() != null && plat1Ref.getSite() != null) + { + assertEquals(plat1.getSite().getId().getValue(), plat1Ref.getSite().getId().getValue()); + assertEquals(plat1.getSite().getDisplayName(), plat1Ref.getSiteName()); + } + else + { + assertNull(plat1.getSite()); + assertNull(plat1Ref.getSite()); + } + assertEquals(plat2.getAgency(), plat2Ref.getAgency()); + assertEquals(plat2.getDescription(), plat2Ref.getDescription()); + assertEquals(plat2.getPlatformDesignator(), plat2Ref.getPlatformDesignator()); + assertEquals(plat2.getConfigName(), plat2Ref.getConfigName()); + assertEquals(plat2.getId().getValue(), plat2Ref.getId().getValue()); + assertEquals(plat2.getConfig().getId().getValue(), plat2Ref.getConfig().getId().getValue()); + assertEquals(plat2.getConfig().getEquipmentModel().getId().getValue(), plat2Ref.getConfig().getEquipmentModel().getId().getValue()); + assertEquals(plat2.getConfig().getEquipmentModel().getName(), plat2Ref.getConfig().getEquipmentModel().getName()); + assertPlatMatchIterators(plat2.getPlatformSensors(), plat2Ref.getPlatformSensors()); + assertTransportMatch(plat2.getTransportMedia(), plat2Ref.getTransportMedia()); + assertEquals(plat2.getProperties(), plat2Ref.getProperties()); + assertEquals(plat2.getBriefDescription(), plat2Ref.getBriefDescription()); + assertEquals(plat2.getDisplayName(), plat2Ref.getDisplayName()); + if (plat2.getSite() != null && plat2Ref.getSite() != null) + { + assertEquals(plat2.getSite().getId().getValue(), plat2Ref.getSite().getId().getValue()); + assertEquals(plat2.getSite().getDisplayName(), plat2Ref.getSiteName()); + } + else + { + assertNull(plat2.getSite()); + assertNull(plat2Ref.getSite()); + } + } + + @Test + void testPlatformMap() throws Exception + { + DbKey platId1 = DbKey.createDbKey(556774L); + Platform plat1 = new Platform(); + plat1.setAgency("USGS"); + plat1.setDescription("Platform 1"); + plat1.setPlatformDesignator("Platform Designator"); + plat1.setConfigName("Platform Configuration"); + plat1.setIsComplete(true); + plat1.setId(platId1); + Site site = new Site(); + site.setId(DbKey.createDbKey(1234L)); + plat1.setSite(site); + PlatformConfig config = new PlatformConfig(); + config.setId(DbKey.createDbKey(33565L)); + config.configName = plat1.getConfigName(); + config.numPlatformsUsing = 11; + config.description = "Platform configuration data"; + EquipmentModel model = new EquipmentModel(); + model.model = "Model 1"; + model.description = "Equipment model 1"; + model.setId(DbKey.createDbKey(555584L)); + model.name = "New Model"; + model.company = "RMA"; + Properties properties = new Properties(); + properties.setProperty("prop1", "value1"); + model.properties = properties; + config.equipmentModel = model; + Vector scripts = new Vector<>(); + DecodesScript script = new DecodesScript + .DecodesScriptBuilder(new DecodesScriptParser()).platformConfig(config) + .scriptName("Integration Testing Script").build(); + ScriptSensor sensor = new ScriptSensor(script, 22); + script.addScriptSensor(sensor); + scripts.add(script); + config.decodesScripts = scripts; + plat1.setConfig(config); + + ApiPlatform plat = map(plat1); + assertNotNull(plat); + + assertEquals(plat1.getAgency(), plat.getAgency()); + assertEquals(plat1.getDescription(), plat.getDescription()); + assertEquals(plat1.getPlatformDesignator(), plat.getDesignator()); + assertEquals(plat1.getId().getValue(), plat.getPlatformId()); + assertEquals(plat1.getConfig().getId().getValue(), plat.getConfigId()); + assertMatch(plat.getPlatformSensors(), plat1.getPlatformSensors()); + assertMatchMedium(plat.getTransportMedia(), plat1.getTransportMedia()); + assertEquals(plat1.getProperties(), plat.getProperties()); + assertEquals(plat1.getSite().getId().getValue(), plat.getSiteId()); + assertPlatMatch(plat1.getPlatformSensors(), plat.getPlatformSensors()); + assertMatch(plat1.getTransportMedia(), plat.getTransportMedia()); + assertEquals(plat1.lastModifyTime, plat.getLastModified()); + } + + private void assertPlatMatch(Iterator platSensors, ArrayList apiPlatSensors) + { + assertEquals(apiPlatSensors.size(), iterSize(platSensors)); + int i = 0; + while (platSensors.hasNext()) + { + PlatformSensor platSensor = platSensors.next(); + ApiPlatformSensor apiSensor = apiPlatSensors.get(i); + + assertEquals(platSensor.sensorNumber, apiSensor.getSensorNum()); + assertEquals(platSensor.site.getId().getValue(), apiSensor.getActualSiteId()); + assertEquals(platSensor.getProperties(), apiSensor.getSensorProps()); + assertEquals(platSensor.getUsgsDdno(), apiSensor.getUsgsDdno()); + + i++; + } + } + + private void assertPlatMatchIterators(Iterator platSensors, Iterator otherPlatSensors) + { + assertEquals(iterSize(platSensors), iterSize(otherPlatSensors)); + + while (platSensors.hasNext()) + { + PlatformSensor sensorA = platSensors.next(); + PlatformSensor sensorB = otherPlatSensors.next(); + assertEquals(sensorA.sensorNumber, sensorB.sensorNumber); + assertEquals(sensorA.site.getId().getValue(), sensorB.site.getId().getValue()); + assertEquals(sensorA.getProperties(), sensorB.getProperties()); + assertEquals(sensorA.getUsgsDdno(), sensorB.getUsgsDdno()); + } + } + + private void assertTransportMatch(Iterator expectedTransportMedium, Iterator transportMedium) + { + assertEquals(iterSize(expectedTransportMedium), iterSize(transportMedium)); + + while (expectedTransportMedium.hasNext()) + { + TransportMedium expected = expectedTransportMedium.next(); + TransportMedium actual = transportMedium.next(); + assertEquals(expected.getMediumType(), actual.getMediumType()); + assertEquals(expected.getMediumId(), actual.getMediumId()); + assertEquals(expected.scriptName, actual.scriptName); + assertEquals(expected.channelNum, actual.channelNum); + assertEquals(expected.assignedTime, actual.assignedTime); + assertEquals(expected.transmitWindow, actual.transmitWindow); + assertEquals(expected.transmitInterval, actual.transmitInterval); + assertEquals(expected.getTimeZone(), actual.getTimeZone()); + assertEquals(expected.getBaud(), actual.getBaud()); + assertEquals(expected.getStopBits(), actual.getStopBits()); + assertEquals(expected.getDataBits(), actual.getDataBits()); + assertEquals(expected.getParity(), actual.getParity()); + assertEquals(expected.getUsername(), actual.getUsername()); + assertEquals(expected.getPassword(), actual.getPassword()); + assertEquals(expected.isDoLogin(), actual.isDoLogin()); + } + } + + private void assertMatch(Iterator transportMed, ArrayList apiTransportMed) + { + assertEquals(apiTransportMed.size(), iterSize(transportMed)); + int i = 0; + while (transportMed.hasNext()) + { + TransportMedium transportMedium = transportMed.next(); + ApiTransportMedium apiTransportMedium = apiTransportMed.get(i); + + assertEquals(transportMedium.getMediumType(), apiTransportMedium.getMediumType()); + assertEquals(transportMedium.getMediumId(), apiTransportMedium.getMediumId()); + assertEquals(transportMedium.scriptName, apiTransportMedium.getScriptName()); + assertEquals(transportMedium.channelNum, apiTransportMedium.getChannelNum()); + assertEquals(transportMedium.assignedTime, apiTransportMedium.getAssignedTime()); + assertEquals(transportMedium.transmitWindow, apiTransportMedium.getTransportWindow()); + assertEquals(transportMedium.transmitInterval, apiTransportMedium.getTransportInterval()); + assertEquals(transportMedium.getTimeZone(), apiTransportMedium.getTimezone()); + assertEquals(transportMedium.getBaud(), apiTransportMedium.getBaud()); + assertEquals(transportMedium.getStopBits(), apiTransportMedium.getStopBits()); + assertEquals(transportMedium.getDataBits(), apiTransportMedium.getDataBits()); + assertEquals(transportMedium.getParity(), apiTransportMedium.getParity().charAt(0)); + assertEquals(transportMedium.getUsername(), apiTransportMedium.getUsername()); + assertEquals(transportMedium.getPassword(), apiTransportMedium.getPassword()); + assertEquals(transportMedium.isDoLogin(), apiTransportMedium.getDoLogin()); + + i++; + } + } + + @Test + void testApiPlatformMap() throws Exception + { + ApiPlatform plat = new ApiPlatform(); + plat.setAgency("USGS"); + plat.setDescription("Platform 10"); + plat.setDesignator("Platform Designator"); + plat.setConfigId(33565L); + plat.setPlatformId(556774L); + ArrayList platSensors = new ArrayList<>(); + ApiPlatformSensor ps = new ApiPlatformSensor(); + ps.setMax(100.0); + ps.setMin(0.0); + ps.setSensorNum(22); + ps.setActualSiteId(1234L); + ps.setUsgsDdno(1534); + Properties props = new Properties(); + props.setProperty("prop1", "value1"); + ps.setSensorProps(props); + platSensors.add(ps); + plat.setPlatformSensors(platSensors); + plat.setSiteId(1234L); + plat.setLastModified(Date.from(Instant.parse("2021-07-01T12:00:00Z"))); + plat.setProduction(true); + + Platform result = map(plat); + + assertNotNull(result); + assertEquals(plat.getAgency(), result.getAgency()); + assertEquals(plat.getDescription(), result.getDescription()); + assertEquals(plat.getDesignator(), result.getPlatformDesignator()); + assertEquals(plat.getPlatformId(), result.getId().getValue()); + assertEquals(plat.getConfigId(), result.getConfig().getId().getValue()); + assertMatch(plat.getPlatformSensors(), result.getPlatformSensors()); + assertMatchMedium(plat.getTransportMedia(), result.getTransportMedia()); + assertEquals(plat.getProperties(), result.getProperties()); + assertEquals(plat.getLastModified(), result.lastModifyTime); + } + + private static void assertMatch(ArrayList apiPlatformSensors, Iterator platformSensors) + { + assertEquals(apiPlatformSensors.size(), iterSize(platformSensors)); + int i = 0; + while (platformSensors.hasNext()) + { + PlatformSensor platformSensor = platformSensors.next(); + ApiPlatformSensor apiPlatformSensor = apiPlatformSensors.get(i); + + assertEquals(platformSensor.sensorNumber, apiPlatformSensor.getSensorNum()); + assertEquals(platformSensor.site.getId().getValue(), apiPlatformSensor.getActualSiteId()); + assertEquals(platformSensor.getProperties(), apiPlatformSensor.getSensorProps()); + assertEquals(platformSensor.getUsgsDdno(), apiPlatformSensor.getUsgsDdno()); + + i++; + } + } + + private static void assertMatchMedium(ArrayList apiTransportMedium, Iterator transportMedium) + { + assertEquals(apiTransportMedium.size(), iterSize(transportMedium)); + int i = 0; + while (transportMedium.hasNext()) + { + TransportMedium tm = transportMedium.next(); + ApiTransportMedium atm = apiTransportMedium.get(i); + + assertEquals(tm.getMediumType(), atm.getMediumType()); + assertEquals(tm.getMediumId(), atm.getMediumId()); + assertEquals(tm.scriptName, atm.getScriptName()); + assertEquals(tm.channelNum, atm.getChannelNum()); + assertEquals(tm.assignedTime, atm.getAssignedTime()); + assertEquals(tm.transmitWindow, atm.getTransportWindow()); + assertEquals(tm.transmitInterval, atm.getTransportInterval()); + assertEquals(tm.getTimeZone(), atm.getTimezone()); + assertEquals(tm.getBaud(), atm.getBaud()); + assertEquals(tm.getStopBits(), atm.getStopBits()); + assertEquals(tm.getDataBits(), atm.getDataBits()); + assertEquals(tm.getParity(), atm.getParity().charAt(0)); + assertEquals(tm.getUsername(), atm.getUsername()); + assertEquals(tm.getPassword(), atm.getPassword()); + assertEquals(tm.isDoLogin(), atm.getDoLogin()); + } + } + + @Test + void testPlatformStatusMap() + { + PlatformStatus status = new PlatformStatus(DbKey.createDbKey(9987500L)); + status.setDesignator("Platform Designator"); + status.setAnnotation("Platform Annotation"); + status.setChecked(true); + status.setLastContactTime(Date.from(Instant.parse("2021-07-02T12:00:00Z"))); + status.setSiteName("Platform location"); + status.setLastFailureCodes("System Failure 2"); + status.setLastErrorTime(Date.from(Instant.parse("2021-07-01T12:00:00Z"))); + + List apiStatus = map(status); + assertNotNull(apiStatus); + assertFalse(apiStatus.isEmpty()); + assertEquals(1, apiStatus.size()); + ApiPlatformStatus apiStat = apiStatus.get(0); + assertEquals(status.getAnnotation(), apiStat.getAnnotation()); + assertEquals(status.getLastContactTime(), apiStat.getLastContact()); + assertEquals(status.getPlatformId().getValue(), apiStat.getPlatformId()); + assertEquals(status.getLastRoutingSpecName(), apiStat.getRoutingSpecName()); + } + + private static int iterSize(Iterator it) + { + int n = 0; + while(it.hasNext()) + { + it.next(); + n++; + } + return n; + } +} \ No newline at end of file