diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/DatatypeUnitResources.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/DatatypeUnitResources.java index 9b91350ce..bb1c42185 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/DatatypeUnitResources.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/DatatypeUnitResources.java @@ -15,9 +15,12 @@ package org.opendcs.odcsapi.res; -import java.sql.SQLException; -import java.util.logging.Logger; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + 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; @@ -30,14 +33,29 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; +import decodes.db.Constants; +import decodes.db.DataTypeSet; +import decodes.db.DatabaseException; +import decodes.db.DatabaseIO; +import decodes.db.EngineeringUnit; +import decodes.db.EngineeringUnitList; +import decodes.db.LinearConverter; +import decodes.db.NullConverter; +import decodes.db.Poly5Converter; +import decodes.db.UnitConverter; +import decodes.db.UnitConverterDb; +import decodes.db.UnitConverterSet; +import decodes.db.UsgsStdConverter; +import decodes.sql.DbKey; +import decodes.tsdb.DbIoException; +import opendcs.dai.DataTypeDAI; +import org.opendcs.odcsapi.beans.ApiDataType; import org.opendcs.odcsapi.beans.ApiUnit; import org.opendcs.odcsapi.beans.ApiUnitConverter; -import org.opendcs.odcsapi.dao.ApiUnitDAO; import org.opendcs.odcsapi.dao.DbException; +import org.opendcs.odcsapi.errorhandling.MissingParameterException; import org.opendcs.odcsapi.errorhandling.WebAppException; -import org.opendcs.odcsapi.hydrojson.DbInterface; import org.opendcs.odcsapi.util.ApiConstants; -import org.opendcs.odcsapi.util.ApiHttpUtil; /** * HTTP Resources relating to DataTypes, Engineering Units, and Conversions @@ -45,7 +63,7 @@ * */ @Path("/") -public class DatatypeUnitResources +public class DatatypeUnitResources extends OpenDcsResource { @Context HttpHeaders httpHeaders; @@ -55,12 +73,40 @@ public class DatatypeUnitResources @RolesAllowed({ApiConstants.ODCS_API_GUEST}) public Response getDataTypeList(@QueryParam("standard") String std) throws DbException { - Logger.getLogger(ApiConstants.loggerName).fine("getDataTypeList"); - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + try (DataTypeDAI dai = getLegacyTimeseriesDB().makeDataTypeDAO()) + { + DataTypeSet set = new DataTypeSet(); + dai.readDataTypeSet(set, std); + return Response.status(HttpServletResponse.SC_OK).entity(map(set)).build(); + } + catch(DbIoException e) + { + throw new DbException("Unable to retrieve data type list", e); + } + } + + static ArrayList map(DataTypeSet set) + { + ArrayList ret = new ArrayList<>(); + Iterator it = set.iterator(); + while(it.hasNext()) { - return ApiHttpUtil.createResponse(dao.getDataTypeList(std)); + decodes.db.DataType dt = it.next(); + ApiDataType adt = new ApiDataType(); + if (dt.getId() != null) + { + adt.setId(dt.getId().getValue()); + } + else + { + adt.setId(DbKey.NullKey.getValue()); + } + adt.setCode(dt.getCode()); + adt.setStandard(dt.getStandard()); + adt.setDisplayName(dt.getDisplayName()); + ret.add(adt); } + return ret; } @@ -70,31 +116,67 @@ public Response getDataTypeList(@QueryParam("standard") String std) throws DbExc @RolesAllowed({ApiConstants.ODCS_API_GUEST}) public Response getUnitList() throws DbException { - - Logger.getLogger(ApiConstants.loggerName).fine("getUnitList"); - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + DatabaseIO dbIo = getLegacyDatabase(); + try + { + EngineeringUnitList euList = new EngineeringUnitList(); + dbIo.readEngineeringUnitList(euList); + return Response.status(HttpServletResponse.SC_OK).entity(map(euList)).build(); + } + catch(DatabaseException e) + { + throw new DbException("Unable to retrieve data type list", e); + } + finally + { + dbIo.close(); + } + } + + static ArrayList map(EngineeringUnitList unitList) + { + ArrayList ret = new ArrayList<>(); + Iterator it = unitList.iterator(); + while(it.hasNext()) { - return ApiHttpUtil.createResponse(dao.getUnitList()); + EngineeringUnit eu = it.next(); + ApiUnit apiUnit = new ApiUnit(); + apiUnit.setAbbr(eu.abbr); + apiUnit.setName(eu.getName()); + apiUnit.setMeasures(eu.measures); + apiUnit.setFamily(eu.family); + ret.add(apiUnit); } + return ret; + } - + @POST @Path("eu") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({ApiConstants.ODCS_API_ADMIN, ApiConstants.ODCS_API_USER}) public Response postEU(@QueryParam("fromabbr") String fromabbr, ApiUnit eu) - throws WebAppException, DbException, SQLException + throws DbException { - Logger.getLogger(ApiConstants.loggerName).fine("postEU abbr=" + eu.getAbbr() - + ", fromabbr=" + fromabbr); - - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + DatabaseIO dbIo = getLegacyDatabase(); + try + { + EngineeringUnit unit = new EngineeringUnit(fromabbr, eu.getName(), eu.getFamily(), eu.getMeasures()); + EngineeringUnitList euList = new EngineeringUnitList(); + dbIo.readEngineeringUnitList(euList); + euList.add(unit); + dbIo.writeEngineeringUnitList(euList); + return Response.status(HttpServletResponse.SC_CREATED) + .entity(map(euList)).build(); + } + catch(DatabaseException e) + { + throw new DbException("Unable to store Engineering Unit list", e); + } + finally { - dao.writeEU(eu, fromabbr); - return ApiHttpUtil.createResponse("{\"message\": \"The Engineering Unit was Saved successfully.\"}"); + dbIo.close(); } } @@ -103,17 +185,27 @@ public Response postEU(@QueryParam("fromabbr") String fromabbr, ApiUnit eu) @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({ApiConstants.ODCS_API_ADMIN, ApiConstants.ODCS_API_USER}) - public Response deleteEU(@QueryParam("abbr") String abbr) throws DbException + public Response deleteEU(@QueryParam("abbr") String abbr) throws DbException, WebAppException { - Logger.getLogger(ApiConstants.loggerName).fine( - "DELETE EU abbr=" + abbr); - - // Use username and password to attempt to connect to the database - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + if (abbr == null) + { + throw new MissingParameterException("Missing required abbr parameter"); + } + + DatabaseIO dbIo = getLegacyDatabase(); + try + { + EngineeringUnit unit = new EngineeringUnit(abbr, "", "", ""); + dbIo.deleteEngineeringUnit(unit); + return Response.status(HttpServletResponse.SC_NO_CONTENT).entity("EU with abbr " + abbr + " deleted").build(); + } + catch(DatabaseException e) + { + throw new DbException("Unable to store Engineering Unit list", e); + } + finally { - dao.deleteEU(abbr); - return ApiHttpUtil.createResponse("EU with abbr " + abbr + " deleted"); + dbIo.close(); } } @@ -123,30 +215,140 @@ public Response deleteEU(@QueryParam("abbr") String abbr) throws DbException @RolesAllowed({ApiConstants.ODCS_API_GUEST}) public Response getUnitConvList() throws DbException { - Logger.getLogger(ApiConstants.loggerName).fine("getUnitConvList"); - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + DatabaseIO dbIo = getLegacyDatabase(); + try { - return ApiHttpUtil.createResponse(dao.getConverterList(false)); + UnitConverterSet unitConverterSet = new UnitConverterSet(); + dbIo.readUnitConverterSet(unitConverterSet); + return Response.status(HttpServletResponse.SC_OK).entity(map(unitConverterSet)).build(); } + catch(DatabaseException e) + { + throw new DbException("Unable to retrieve Unit Converter list", e); + } + finally + { + dbIo.close(); + } + } + + static List map(UnitConverterSet unitSet) + { + List ret = new ArrayList<>(); + Iterator it = unitSet.iteratorDb(); + while (it.hasNext()) + { + UnitConverterDb unitConv = it.next(); + ApiUnitConverter euc = map(unitConv); + ret.add(euc); + } + return ret; } - + @POST @Path("euconv") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({ApiConstants.ODCS_API_ADMIN, ApiConstants.ODCS_API_USER}) - public Response postEUConv(ApiUnitConverter euc) throws WebAppException, DbException + public Response postEUConv(ApiUnitConverter euc) throws DbException { - Logger.getLogger(ApiConstants.loggerName).fine("postEUConv from=" - + euc.getFromAbbr() + ", to=" + euc.getToAbbr()); - - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) + DatabaseIO dbIo = getLegacyDatabase(); + try { - dao.writeEUConv(euc); - return ApiHttpUtil.createResponse("EUConv Saved"); + UnitConverterDb unitConverterDb = ucDbMap(euc); + dbIo.insertUnitConverter(unitConverterDb); + return Response.status(HttpServletResponse.SC_CREATED).entity(map(unitConverterDb)).build(); } + catch(DatabaseException e) + { + throw new DbException("Unable to store Unit Converter list", e); + } + finally + { + dbIo.close(); + } + } + + static ApiUnitConverter map(UnitConverterDb dbConv) + { + ApiUnitConverter euc = new ApiUnitConverter(); + if (dbConv.getId() != null) + { + euc.setUcId(dbConv.getId().getValue()); + } + else + { + euc.setUcId(DbKey.NullKey.getValue()); + } + euc.setFromAbbr(dbConv.fromAbbr); + euc.setToAbbr(dbConv.toAbbr); + euc.setAlgorithm(dbConv.algorithm); + euc.setA(dbConv.coefficients[0] == 0.0 ? null : dbConv.coefficients[0]); + euc.setB(dbConv.coefficients[1] == 0.0 ? null : dbConv.coefficients[1]); + euc.setC(dbConv.coefficients[2] == 0.0 ? null : dbConv.coefficients[2]); + euc.setD(dbConv.coefficients[3] == 0.0 ? null : dbConv.coefficients[3]); + euc.setE(dbConv.coefficients[4] == 0.0 ? null : dbConv.coefficients[4]); + euc.setF(dbConv.coefficients[5] == 0.0 ? null : dbConv.coefficients[5]); + return euc; + } + + static UnitConverterDb ucDbMap(ApiUnitConverter euc) throws DatabaseException, DbException + { + UnitConverterDb unitConverterDb = new UnitConverterDb(euc.getFromAbbr(), euc.getToAbbr()); + if (euc.getUcId() != null) + { + unitConverterDb.setId(DbKey.createDbKey(euc.getUcId())); + } + else + { + unitConverterDb.setId(DbKey.NullKey); + } + + unitConverterDb.algorithm = euc.getAlgorithm(); + unitConverterDb.coefficients[0] = euc.getA() == null ? 0.0 : euc.getA(); + unitConverterDb.coefficients[1] = euc.getB() == null ? 0.0 : euc.getB(); + unitConverterDb.coefficients[2] = euc.getC() == null ? 0.0 : euc.getC(); + unitConverterDb.coefficients[3] = euc.getD() == null ? 0.0 : euc.getD(); + unitConverterDb.coefficients[4] = euc.getE() == null ? 0.0 : euc.getE(); + unitConverterDb.coefficients[5] = euc.getF() == null ? 0.0 : euc.getF(); + unitConverterDb.execConverter = ucMap(euc); + return unitConverterDb; + } + + static UnitConverter ucMap(ApiUnitConverter euc) throws DbException + { + UnitConverter unitConverter; + EngineeringUnit fromEU = new EngineeringUnit(euc.getFromAbbr(), "", "", ""); + EngineeringUnit toEU = new EngineeringUnit(euc.getToAbbr(), "", "", ""); + if (euc.getAlgorithm().equalsIgnoreCase(Constants.eucvt_poly5)) + { + unitConverter = new Poly5Converter(fromEU, toEU); + } + else if (euc.getAlgorithm().equalsIgnoreCase(Constants.eucvt_linear)) + { + unitConverter = new LinearConverter(fromEU, toEU); + } + else if (euc.getAlgorithm().equalsIgnoreCase(Constants.eucvt_none)) + { + unitConverter = new NullConverter(fromEU, toEU); + } + else if (euc.getAlgorithm().equalsIgnoreCase(Constants.eucvt_usgsstd)) + { + unitConverter = new UsgsStdConverter(fromEU, toEU); + } + else + { + throw new DbException("Unknown algorithm: " + euc.getAlgorithm()); + } + double[] coeffs = new double[6]; + coeffs[0] = euc.getA() == null ? 0.0 : euc.getA(); + coeffs[1] = euc.getB() == null ? 0.0 : euc.getB(); + coeffs[2] = euc.getC() == null ? 0.0 : euc.getC(); + coeffs[3] = euc.getD() == null ? 0.0 : euc.getD(); + coeffs[4] = euc.getE() == null ? 0.0 : euc.getE(); + coeffs[5] = euc.getF() == null ? 0.0 : euc.getF(); + unitConverter.setCoefficients(coeffs); + return unitConverter; } @DELETE @@ -154,17 +356,25 @@ public Response postEUConv(ApiUnitConverter euc) throws WebAppException, DbExcep @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({ApiConstants.ODCS_API_ADMIN, ApiConstants.ODCS_API_USER}) - public Response deleteEUConv(@QueryParam("euconvid") Long id) throws DbException + public Response deleteEUConv(@QueryParam("euconvid") Long id) throws DbException, WebAppException { - Logger.getLogger(ApiConstants.loggerName).fine( - "DELETE EUConverter id=" + id); - - // Use username and password to attempt to connect to the database - try (DbInterface dbi = new DbInterface(); - ApiUnitDAO dao = new ApiUnitDAO(dbi)) - { - dao.deleteEUConv(id); - return ApiHttpUtil.createResponse("EUConv with id=" + id + " deleted"); + if (id == null) + { + throw new MissingParameterException("Missing required euconvid parameter"); + } + DatabaseIO dbIo = getLegacyDatabase(); + try + { + dbIo.deleteUnitConverter(id); + return Response.status(HttpServletResponse.SC_NO_CONTENT).entity("EUConv with id=" + id + " deleted").build(); + } + catch(DatabaseException e) + { + throw new DbException("Unable to delete Unit Converter", e); + } + finally + { + dbIo.close(); } } } diff --git a/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/DatatypeUnitResourcesTest.java b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/DatatypeUnitResourcesTest.java new file mode 100644 index 000000000..7c29c996e --- /dev/null +++ b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/DatatypeUnitResourcesTest.java @@ -0,0 +1,190 @@ +package org.opendcs.odcsapi.res; + +import java.util.ArrayList; +import java.util.List; + +import decodes.db.DataType; +import decodes.db.DataTypeSet; +import decodes.db.EngineeringUnit; +import decodes.db.EngineeringUnitList; +import decodes.db.UnitConverter; +import decodes.db.UnitConverterDb; +import decodes.db.UnitConverterSet; +import decodes.sql.DbKey; +import org.junit.jupiter.api.Test; +import org.opendcs.odcsapi.beans.ApiDataType; +import org.opendcs.odcsapi.beans.ApiUnit; +import org.opendcs.odcsapi.beans.ApiUnitConverter; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.opendcs.odcsapi.res.DatatypeUnitResources.map; +import static org.opendcs.odcsapi.res.DatatypeUnitResources.ucDbMap; +import static org.opendcs.odcsapi.res.DatatypeUnitResources.ucMap; + +final class DatatypeUnitResourcesTest +{ + @Test + void testMapUnitConverter() throws Exception + { + ApiUnitConverter auc = new ApiUnitConverter(); + auc.setFromAbbr("ft"); + auc.setToAbbr("m"); + auc.setAlgorithm("None"); + auc.setA(1.0); + auc.setB(2.0); + auc.setC(3.0); + auc.setD(4.0); + auc.setE(5.0); + auc.setF(6.0); + auc.setUcId(1234L); + UnitConverterDb ucs = ucDbMap(auc); + + assertNotNull(ucs); + ucs.prepareForExec(); + assertTrue(ucs.isPrepared()); + assertEquals(1234L, ucs.getId().getValue()); + assertEquals("ft->m", ucs.toString()); + assertEquals("ft", ucs.fromAbbr); + assertEquals("m", ucs.toAbbr); + assertEquals("None", ucs.algorithm); + assertEquals(1.0, ucs.coefficients[0]); + assertEquals(2.0, ucs.coefficients[1]); + assertEquals(3.0, ucs.coefficients[2]); + assertEquals(4.0, ucs.coefficients[3]); + assertEquals(5.0, ucs.coefficients[4]); + assertEquals(6.0, ucs.coefficients[5]); + } + + @Test + void testUcMap() throws Exception + { + ApiUnitConverter auc = new ApiUnitConverter(); + auc.setFromAbbr("ft"); + auc.setToAbbr("m"); + auc.setAlgorithm("None"); + auc.setA(1.0); + auc.setB(2.0); + auc.setC(3.0); + auc.setD(4.0); + auc.setE(5.0); + auc.setF(6.0); + auc.setUcId(1234L); + + UnitConverter uc = ucMap(auc); + + assertNotNull(uc); + assertEquals("ft", uc.getFromAbbr()); + assertEquals("m", uc.getToAbbr()); + } + + @Test + void testDbUcMap() + { + UnitConverterDb ucdb = new UnitConverterDb("ft", "m"); + ucdb.algorithm = "none"; + ucdb.coefficients[0] = 1.0; + ucdb.coefficients[1] = 2.0; + ucdb.coefficients[2] = 3.0; + ucdb.coefficients[3] = 4.0; + ucdb.coefficients[4] = 5.0; + ucdb.coefficients[5] = 6.0; + ucdb.forceSetId(DbKey.createDbKey(1234L)); + + ApiUnitConverter auc = map(ucdb); + + assertNotNull(auc); + assertEquals(ucdb.fromAbbr, auc.getFromAbbr()); + assertEquals(ucdb.toAbbr, auc.getToAbbr()); + assertEquals(ucdb.algorithm, auc.getAlgorithm()); + assertEquals(ucdb.coefficients[0], auc.getA()); + assertEquals(ucdb.coefficients[1], auc.getB()); + assertEquals(ucdb.coefficients[2], auc.getC()); + assertEquals(ucdb.coefficients[3], auc.getD()); + assertEquals(ucdb.coefficients[4], auc.getE()); + assertEquals(ucdb.coefficients[5], auc.getF()); + assertEquals(ucdb.getId().getValue(), auc.getUcId()); + } + + @Test + void testUnitListMap() + { + EngineeringUnitList eul = new EngineeringUnitList(); + EngineeringUnit eu = new EngineeringUnit("C", "Celsius", "Metric", "temperature"); + EngineeringUnit eu2 = new EngineeringUnit("K", "Kelvin", "Metric", "temperature"); + eul.add(eu); + eul.add(eu2); + + ArrayList apiUnits = map(eul); + assertNotNull(apiUnits); + assertEquals(2, apiUnits.size()); + assertEquals("C", apiUnits.get(0).getAbbr()); + assertEquals("Celsius", apiUnits.get(0).getName()); + assertEquals("Metric", apiUnits.get(0).getFamily()); + assertEquals("temperature", apiUnits.get(0).getMeasures()); + assertEquals("K", apiUnits.get(1).getAbbr()); + assertEquals("Kelvin", apiUnits.get(1).getName()); + assertEquals("Metric", apiUnits.get(1).getFamily()); + assertEquals("temperature", apiUnits.get(1).getMeasures()); + } + + @Test + void testUnitConvertMap() + { + UnitConverterSet unitSet = new UnitConverterSet(); + UnitConverterDb unitDb = new UnitConverterDb("ft", "m"); + unitDb.algorithm = "none"; + unitDb.coefficients[0] = 1.0; + unitDb.coefficients[1] = 2.0; + unitDb.coefficients[2] = 3.0; + unitDb.coefficients[3] = 4.0; + unitDb.coefficients[4] = 5.0; + unitDb.coefficients[5] = 6.0; + unitSet.addDbConverter(unitDb); + unitDb.forceSetId(DbKey.createDbKey(1234L)); + List unitConverterList = map(unitSet); + assertNotNull(unitConverterList); + assertEquals(1, unitConverterList.size()); + ApiUnitConverter unitConverter = unitConverterList.get(0); + assertNotNull(unitConverter); + assertEquals(unitDb.fromAbbr, unitConverter.getFromAbbr()); + assertEquals(unitDb.toAbbr, unitConverter.getToAbbr()); + assertEquals(unitDb.algorithm, unitConverter.getAlgorithm()); + assertEquals(unitDb.coefficients[0], unitConverter.getA()); + assertEquals(unitDb.coefficients[1], unitConverter.getB()); + assertEquals(unitDb.coefficients[2], unitConverter.getC()); + assertEquals(unitDb.coefficients[3], unitConverter.getD()); + assertEquals(unitDb.coefficients[4], unitConverter.getE()); + assertEquals(unitDb.coefficients[5], unitConverter.getF()); + assertEquals(unitDb.getId().getValue(), unitConverter.getUcId()); + } + + @Test + void testDataTypeSetMap() throws Exception + { + DataTypeSet dts = new DataTypeSet(); + DataType dt = new DataType("SHEF-PE", "TEST_CODE"); + dt.setId(DbKey.createDbKey(1234L)); + dt.setDisplayName("Test Display Name"); + dts.add(dt); + DataType dt2 = new DataType("EPA-CODE", "995842215"); + dt2.setId(DbKey.createDbKey(5678L)); + dt2.setDisplayName("Test Display Name 2"); + dts.add(dt2); + + ArrayList apiDataTypes = map(dts); + assertNotNull(apiDataTypes); + assertEquals(2, apiDataTypes.size()); + ApiDataType apiDataType = apiDataTypes.get(0); + assertEquals(dt.getCode(), apiDataType.getCode()); + assertEquals(dt.getId().getValue(), apiDataType.getId()); + assertEquals(dt.getDisplayName(), apiDataType.getDisplayName()); + assertEquals(dt.getStandard(), apiDataType.getStandard()); + ApiDataType apiDataType2 = apiDataTypes.get(1); + assertEquals(dt2.getCode(), apiDataType2.getCode()); + assertEquals(dt2.getId().getValue(), apiDataType2.getId()); + assertEquals(dt2.getDisplayName(), apiDataType2.getDisplayName()); + assertEquals(dt2.getStandard(), apiDataType2.getStandard()); + } +} diff --git a/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/it/DatatypeUnitResourcesIT.java b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/it/DatatypeUnitResourcesIT.java new file mode 100644 index 000000000..7c8f8be8a --- /dev/null +++ b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/it/DatatypeUnitResourcesIT.java @@ -0,0 +1,677 @@ +package org.opendcs.odcsapi.res.it; + +import java.util.List; +import java.util.Map; +import javax.servlet.http.HttpServletResponse; +import javax.ws.rs.core.MediaType; + +import com.fasterxml.jackson.databind.ObjectMapper; +import io.restassured.filter.log.LogDetail; +import io.restassured.filter.session.SessionFilter; +import io.restassured.path.json.JsonPath; +import io.restassured.response.ExtractableResponse; +import io.restassured.response.Response; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.TestTemplate; +import org.junit.jupiter.api.extension.ExtendWith; +import org.opendcs.odcsapi.beans.ApiUnit; +import org.opendcs.odcsapi.beans.ApiUnitConverter; +import org.opendcs.odcsapi.fixtures.DatabaseContextProvider; + +import static io.restassured.RestAssured.given; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; + +@Tag("integration-opentsdb-only") +@ExtendWith(DatabaseContextProvider.class) +final class DatatypeUnitResourcesIT extends BaseIT +{ + private static SessionFilter sessionFilter; + private static Long converterId; + private static String euAbbr; + private static String euAbbr2; + + @BeforeEach + public void setUp() throws Exception + { + setUpCreds(); + sessionFilter = new SessionFilter(); + authenticate(sessionFilter); + + ObjectMapper mapper = new ObjectMapper(); + ApiUnit eu = getDtoFromResource("datatypeunit_engineering_unit_insert_data.json", + ApiUnit.class); + euAbbr = eu.getAbbr(); + String euJson = mapper.writeValueAsString(eu); + + // Store the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(euJson) + .queryParam("fromabbr", euAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + ; + + ApiUnit eu2 = getDtoFromResource("datatypeunit_engineering_unit_2_insert_data.json", + ApiUnit.class); + euAbbr2 = eu2.getAbbr(); + euJson = mapper.writeValueAsString(eu2); + + // Store the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(euJson) + .queryParam("fromabbr", euAbbr2) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + ; + + // retrieve the EU List and assert it contains the EUs + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(euJson) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("unitlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> actualList = actual.getList(""); + boolean foundFirst = false; + boolean foundSecond = false; + for (Map item : actualList) + { + if (item.get("abbr").equals(euAbbr)) + { + assertEquals(euAbbr, item.get("abbr")); + assertEquals(eu.getName(), item.get("name")); + assertEquals(eu.getFamily(), item.get("family")); + assertEquals(eu.getMeasures(), item.get("measures")); + foundFirst = true; + } + else if (item.get("abbr").equals(euAbbr2)) + { + assertEquals(euAbbr2, item.get("abbr")); + assertEquals(eu2.getName(), item.get("name")); + assertEquals(eu2.getFamily(), item.get("family")); + assertEquals(eu2.getMeasures(), item.get("measures")); + foundSecond = true; + } + } + assertTrue(foundFirst); + assertTrue(foundSecond); + + + String unitConverterJson = getJsonFromResource("datatypeunit_insert_euconv_data.json"); + + // Store the EU Converter + response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(unitConverterJson) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("euconv") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + .extract() + ; + + converterId = response.body().jsonPath().getLong("ucId"); + } + + @AfterEach + public void tearDown() + { + // Delete the EU Converter + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("euconvid", converterId) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("euconv") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Delete the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("abbr", euAbbr2) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Delete the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("abbr", euAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + logout(sessionFilter); + } + + @TestTemplate + void testGetDataTypeList() + { + JsonPath expected = getJsonPathFromResource("datatypeunit_get_type_list_expected.json"); + + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("datatypelist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> actualList = actual.getList(""); + List> expectedList = expected.getList(""); + + int numFound = 0; + for (Map expectedItem : expectedList) + { + for (Map actualItem : actualList) + { + if (expectedItem.get("displayName").equals(actualItem.get("displayName"))) + { + assertEquals(expectedItem.get("displayName"), actualItem.get("displayName")); + assertEquals(expectedItem.get("standard"), actualItem.get("standard")); + numFound++; + } + } + } + assertEquals(expectedList.size(), numFound); + } + + @TestTemplate + void testGetDataTypeListWithFilter() + { + JsonPath expected = getJsonPathFromResource("datatypeunit_get_type_list_expected_filtered.json"); + + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("standard", "CWMS") + .when() + .redirects().follow(true) + .redirects().max(3) + .get("datatypelist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> actualList = actual.getList(""); + List> expectedList = expected.getList(""); + + assertEquals(expectedList.size(), actualList.size()); + + for(Map expectedItem : expectedList) + { + boolean found = false; + for(Map actualItem : actualList) + { + if(expectedItem.get("displayName").equals(actualItem.get("displayName"))) + { + assertEquals(expectedItem.get("code"), actualItem.get("code")); + assertEquals(expectedItem.get("displayName"), actualItem.get("displayName")); + assertEquals(expectedItem.get("unit"), actualItem.get("unit")); + assertEquals(expectedItem.get("unitAbbr"), actualItem.get("unitAbbr")); + found = true; + } + } + assertTrue(found); + } + } + + @TestTemplate + void testGetUnitList() throws Exception + { + ApiUnit expected = getDtoFromResource("datatypeunit_engineering_unit_insert_data.json", + ApiUnit.class); + + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("unitlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> actualList = actual.getList(""); + boolean found = false; + for (Map item : actualList) + { + if (item.get("abbr").equals(expected.getAbbr())) + { + assertEquals(expected.getAbbr(), item.get("abbr")); + assertEquals(expected.getName(), item.get("name")); + assertEquals(expected.getFamily(), item.get("family")); + assertEquals(expected.getMeasures(), item.get("measures")); + found = true; + } + } + assertTrue(found); + } + + @TestTemplate + void testPostAndDeleteEngineeringUnit() throws Exception + { + ApiUnit engineeringUnit = getDtoFromResource("datatypeunit_eu_post_delete_data.json", + ApiUnit.class); + String fromAbbr = engineeringUnit.getAbbr(); + ObjectMapper mapper = new ObjectMapper(); + String euJson = mapper.writeValueAsString(engineeringUnit); + + // Store the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(euJson) + .queryParam("fromabbr", fromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + ; + + JsonPath expected = getJsonPathFromResource("datatypeunit_eu_post_delete_data.json"); + + // Retrieve the EU and assert it matches expected JSON + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("unitlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> actualList = actual.getList(""); + boolean found = false; + for (Map item : actualList) + { + if (item.get("abbr").equals(fromAbbr)) + { + assertEquals(expected.getString("abbr"), item.get("abbr")); + assertEquals(expected.getString("name"), item.get("name")); + assertEquals(expected.getString("family"), item.get("family")); + assertEquals(expected.getString("measures"), item.get("measures")); + found = true; + } + } + assertTrue(found); + + // Delete the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("abbr", fromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Retrieve the EU and assert it is not found + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("eulist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NOT_FOUND)) + ; + } + + @TestTemplate + void testGetUnitConverterList() throws Exception + { + ApiUnitConverter expected = getDtoFromResource("datatypeunit_insert_euconv_data.json", + ApiUnitConverter.class); + + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("euconvlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> expectedMap = actual.getList(""); + boolean found = false; + for (Map item : expectedMap) + { + if (item.get("fromAbbr").equals(expected.getFromAbbr()) && item.get("toAbbr").equals(expected.getToAbbr())) + { + assertEquals(expected.getFromAbbr(), item.get("fromAbbr")); + assertEquals(expected.getToAbbr(), item.get("toAbbr")); + assertEquals(expected.getAlgorithm(), item.get("algorithm")); + assertEquals(expected.getA(), item.get("a") == null ? null : Double.parseDouble(item.get("a").toString())); + assertEquals(expected.getB(), item.get("b") == null ? null : Double.parseDouble(item.get("b").toString())); + assertEquals(expected.getC(), item.get("c") == null ? null : Double.parseDouble(item.get("c").toString())); + assertEquals(expected.getD(), item.get("d") == null ? null : Double.parseDouble(item.get("d").toString())); + assertEquals(expected.getE(), item.get("e") == null ? null : Double.parseDouble(item.get("e").toString())); + assertEquals(expected.getF(), item.get("f") == null ? null : Double.parseDouble(item.get("f").toString())); + found = true; + } + } + assertTrue(found); + } + + @TestTemplate + void testPostAndDeleteUnitConverter() throws Exception + { + ApiUnit engineeringUnit = getDtoFromResource("datatypeunit_eu_post_delete_data.json", + ApiUnit.class); + ApiUnit engineeringToUnit = getDtoFromResource("datatypeunit_euconv_post_delete_new_unit_data.json", + ApiUnit.class); + String fromAbbr = engineeringUnit.getAbbr(); + String newFromAbbr = engineeringToUnit.getAbbr(); + ObjectMapper mapper = new ObjectMapper(); + String unitJson = mapper.writeValueAsString(engineeringUnit); + String newUnitJson = mapper.writeValueAsString(engineeringToUnit); + String converterJson = getJsonFromResource("datatypeunit_euconv_post_delete_data.json"); + + // Store the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(unitJson) + .queryParam("fromabbr", fromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + ; + + // Store the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(newUnitJson) + .queryParam("fromabbr", newFromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + ; + + // Store the EU Converter + ExtractableResponse response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .body(converterJson) + .when() + .redirects().follow(true) + .redirects().max(3) + .post("euconv") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_CREATED)) + .extract() + ; + + Long convId = response.body().jsonPath().getLong("ucId"); + + ApiUnitConverter expected = getDtoFromResource("datatypeunit_euconv_post_delete_data.json", + ApiUnitConverter.class); + + // Retrieve the EU Converter and assert it matches expected JSON + response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("euconvlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + JsonPath actual = response.body().jsonPath(); + List> items = actual.getList(""); + boolean found = false; + for (Map item : items) + { + if (item.get("fromAbbr").equals(expected.getFromAbbr()) && item.get("toAbbr").equals(expected.getToAbbr())) + { + assertEquals(expected.getFromAbbr(), item.get("fromAbbr")); + assertEquals(expected.getToAbbr(), item.get("toAbbr")); + found = true; + } + } + assertTrue(found); + + // Delete the EU Converter + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("euconvid", convId) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("euconv") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Delete the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("abbr", fromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Delete the EU + given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .queryParam("abbr", newFromAbbr) + .when() + .redirects().follow(true) + .redirects().max(3) + .delete("eu") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_NO_CONTENT)) + ; + + // Retrieve the EU Converter and assert it is not found + response = given() + .log().ifValidationFails(LogDetail.ALL, true) + .accept(MediaType.APPLICATION_JSON) + .header("Authorization", authHeader) + .filter(sessionFilter) + .when() + .redirects().follow(true) + .redirects().max(3) + .get("euconvlist") + .then() + .log().ifValidationFails(LogDetail.ALL, true) + .assertThat() + .statusCode(is(HttpServletResponse.SC_OK)) + .extract() + ; + + actual = response.body().jsonPath(); + items = actual.getList(""); + found = false; + for (Map item : items) + { + if (item.get("fromAbbr").equals(expected.getFromAbbr()) && item.get("toAbbr").equals(expected.getToAbbr())) + { + assertEquals(expected.getFromAbbr(), item.get("fromAbbr")); + assertEquals(expected.getToAbbr(), item.get("toAbbr")); + found = true; + } + } + assertFalse(found); + } +} diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_2_insert_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_2_insert_data.json new file mode 100644 index 000000000..117527711 --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_2_insert_data.json @@ -0,0 +1,6 @@ +{ + "abbr": "degC", + "name": "Degrees Celsius", + "family": "Metric", + "measures": "Temperature" +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_insert_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_insert_data.json new file mode 100644 index 000000000..4fafea0ee --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_engineering_unit_insert_data.json @@ -0,0 +1,6 @@ +{ + "abbr": "K", + "name": "Kelvin", + "family": "Metric", + "measures": "temperature" +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_eu_post_delete_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_eu_post_delete_data.json new file mode 100644 index 000000000..827f687dc --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_eu_post_delete_data.json @@ -0,0 +1,6 @@ +{ + "abbr": "dm", + "name": "Deci-Meter", + "family": "Metric", + "measures": "distance" +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_data.json new file mode 100644 index 000000000..68b42b741 --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_data.json @@ -0,0 +1,12 @@ +{ + "ucId" : null, + "fromAbbr" : "dm", + "toAbbr" : "ft", + "algorithm" : "None", + "a" : 0.328084, + "b" : null, + "c" : null, + "d" : null, + "e" : null, + "f" : null +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_new_unit_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_new_unit_data.json new file mode 100644 index 000000000..8dee0d1fc --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_euconv_post_delete_new_unit_data.json @@ -0,0 +1,6 @@ +{ + "abbr": "ft", + "name": "Feet", + "family": "Imperial", + "measures": "distance" +} \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_euconv_list_expected.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_euconv_list_expected.json new file mode 100644 index 000000000..5297cbbde --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_euconv_list_expected.json @@ -0,0 +1,1622 @@ +[ + { + "ucId": 1, + "fromAbbr": "m^3/s", + "toAbbr": "cms", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 2, + "fromAbbr": "ft", + "toAbbr": "in", + "algorithm": "linear", + "a": 12, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 3, + "fromAbbr": "kG", + "toAbbr": "G", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 4, + "fromAbbr": "count", + "toAbbr": "unit", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 5, + "fromAbbr": "G", + "toAbbr": "mG", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 6, + "fromAbbr": "cM", + "toAbbr": "cm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 7, + "fromAbbr": "mi", + "toAbbr": "m", + "algorithm": "linear", + "a": 1609.344, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 8, + "fromAbbr": "acre*ft", + "toAbbr": "ac-ft", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 9, + "fromAbbr": "%", + "toAbbr": "pct", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 10, + "fromAbbr": "inHg", + "toAbbr": "pa", + "algorithm": "linear", + "a": 3386.38, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 11, + "fromAbbr": "mG/L", + "toAbbr": "uG/L", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 12, + "fromAbbr": "kW", + "toAbbr": "W", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 13, + "fromAbbr": "mi^2", + "toAbbr": "mile2", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 14, + "fromAbbr": "M", + "toAbbr": "m", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 15, + "fromAbbr": "ft/s", + "toAbbr": "M/s", + "algorithm": "linear", + "a": 0.3048, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 16, + "fromAbbr": "ac-ft", + "toAbbr": "m3", + "algorithm": "linear", + "a": 1233.4818, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 17, + "fromAbbr": "uMHO", + "toAbbr": "umho", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 18, + "fromAbbr": "MWh", + "toAbbr": "GWh", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 19, + "fromAbbr": "g/l", + "toAbbr": "gm/cm3", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 20, + "fromAbbr": "ft", + "toAbbr": "m", + "algorithm": "linear", + "a": 0.3048, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 21, + "fromAbbr": "kpa", + "toAbbr": "kPa", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 22, + "fromAbbr": "bar", + "toAbbr": "pa", + "algorithm": "linear", + "a": 100000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 23, + "fromAbbr": "mG", + "toAbbr": "uG", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 24, + "fromAbbr": "m", + "toAbbr": "km", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 25, + "fromAbbr": "M/s", + "toAbbr": "m/s", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 26, + "fromAbbr": "qt", + "toAbbr": "pt", + "algorithm": "linear", + "a": 2, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 27, + "fromAbbr": "kM^2", + "toAbbr": "M^2", + "algorithm": "linear", + "a": 1000000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 28, + "fromAbbr": "week", + "toAbbr": "day", + "algorithm": "linear", + "a": 7, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 29, + "fromAbbr": "ft/s", + "toAbbr": "mph", + "algorithm": "linear", + "a": 0.681818181818, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 30, + "fromAbbr": "acre", + "toAbbr": "ft^2", + "algorithm": "linear", + "a": 43560, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 31, + "fromAbbr": "m", + "toAbbr": "cm", + "algorithm": "linear", + "a": 100, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 32, + "fromAbbr": "ft/s", + "toAbbr": "in/s", + "algorithm": "linear", + "a": 12, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 33, + "fromAbbr": "m^3/s", + "toAbbr": "cfs", + "algorithm": "linear", + "a": 35.31466247, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 34, + "fromAbbr": "kj", + "toAbbr": "j", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 35, + "fromAbbr": "cal", + "toAbbr": "j", + "algorithm": "linear", + "a": 4.184, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 36, + "fromAbbr": "min", + "toAbbr": "sec", + "algorithm": "linear", + "a": 60, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 37, + "fromAbbr": "psi", + "toAbbr": "pa", + "algorithm": "linear", + "a": 6874.75729, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 38, + "fromAbbr": "mph", + "toAbbr": "knots", + "algorithm": "linear", + "a": 0.8689762419006, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 39, + "fromAbbr": "kM^2", + "toAbbr": "km2", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 40, + "fromAbbr": "ft^3", + "toAbbr": "ft3", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 41, + "fromAbbr": "V", + "toAbbr": "volt", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 42, + "fromAbbr": "lb", + "toAbbr": "oz", + "algorithm": "linear", + "a": 16, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 43, + "fromAbbr": "pt", + "toAbbr": "floz", + "algorithm": "linear", + "a": 16, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 44, + "fromAbbr": "mL", + "toAbbr": "cc", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 45, + "fromAbbr": "gal", + "toAbbr": "mgal", + "algorithm": "linear", + "a": 0.000001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 46, + "fromAbbr": "gal", + "toAbbr": "qt", + "algorithm": "linear", + "a": 4, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 47, + "fromAbbr": "in/hr", + "toAbbr": "in/day", + "algorithm": "linear", + "a": 0.4166667, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 48, + "fromAbbr": "ft^2", + "toAbbr": "ft2", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 49, + "fromAbbr": "lbf", + "toAbbr": "N", + "algorithm": "linear", + "a": 4.448222, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 50, + "fromAbbr": "kL", + "toAbbr": "L", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 51, + "fromAbbr": "L", + "toAbbr": "mL", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 52, + "fromAbbr": "g/L", + "toAbbr": "mG/L", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 53, + "fromAbbr": "lbf", + "toAbbr": "lb", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 54, + "fromAbbr": "m", + "toAbbr": "um", + "algorithm": "linear", + "a": 1000000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 55, + "fromAbbr": "cfs", + "toAbbr": "ft^3/s", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 56, + "fromAbbr": "btu", + "toAbbr": "j", + "algorithm": "linear", + "a": 1055.056, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 57, + "fromAbbr": "kW", + "toAbbr": "MW", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 58, + "fromAbbr": "yd^2", + "toAbbr": "ft^2", + "algorithm": "linear", + "a": 9, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 59, + "fromAbbr": "Wh", + "toAbbr": "kWh", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 60, + "fromAbbr": "ft/s", + "toAbbr": "in/hr", + "algorithm": "linear", + "a": 43200, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 61, + "fromAbbr": "m", + "toAbbr": "mm", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 62, + "fromAbbr": "mph", + "toAbbr": "kM/hr", + "algorithm": "linear", + "a": 1.609344, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 63, + "fromAbbr": "m3", + "toAbbr": "km3", + "algorithm": "linear", + "a": 1e-9, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 64, + "fromAbbr": "ac-ft", + "toAbbr": "kaf", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 65, + "fromAbbr": "cM^2", + "toAbbr": "M^2", + "algorithm": "linear", + "a": 0.0001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 66, + "fromAbbr": "umho", + "toAbbr": "mho", + "algorithm": "linear", + "a": 0.000001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 67, + "fromAbbr": "uMHOs", + "toAbbr": "uMHOs/cm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 68, + "fromAbbr": "gal", + "toAbbr": "L", + "algorithm": "linear", + "a": 3.785412, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 69, + "fromAbbr": "yd", + "toAbbr": "ft", + "algorithm": "linear", + "a": 3, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 70, + "fromAbbr": "m^3", + "toAbbr": "L", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 71, + "fromAbbr": "mi^2", + "toAbbr": "ft^2", + "algorithm": "linear", + "a": 27878400, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 72, + "fromAbbr": "mho", + "toAbbr": "S", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 73, + "fromAbbr": "kM", + "toAbbr": "km", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 74, + "fromAbbr": "m2", + "toAbbr": "1000 m2", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 75, + "fromAbbr": "GW", + "toAbbr": "TW", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 76, + "fromAbbr": "deg", + "toAbbr": "deg*10", + "algorithm": "linear", + "a": 0.1, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 77, + "fromAbbr": "mL", + "toAbbr": "uL", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 78, + "fromAbbr": "M^2", + "toAbbr": "m2", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 79, + "fromAbbr": "kWh", + "toAbbr": "MWh", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 80, + "fromAbbr": "mi", + "toAbbr": "ft", + "algorithm": "linear", + "a": 5280, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 81, + "fromAbbr": "MW", + "toAbbr": "GW", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 82, + "fromAbbr": "kcfs", + "toAbbr": "cfs", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 83, + "fromAbbr": "gal", + "toAbbr": "kgal", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 84, + "fromAbbr": "ppt", + "toAbbr": "ppm", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 85, + "fromAbbr": "uMHOs", + "toAbbr": "uMHO", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 86, + "fromAbbr": "ft^3", + "toAbbr": "in^3", + "algorithm": "linear", + "a": 1728, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 87, + "fromAbbr": "cM/s", + "toAbbr": "mM/s", + "algorithm": "linear", + "a": 10, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 88, + "fromAbbr": "atm", + "toAbbr": "pa", + "algorithm": "linear", + "a": 101325, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 89, + "fromAbbr": "mmHg", + "toAbbr": "mm-hg", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 90, + "fromAbbr": "acre", + "toAbbr": "ha", + "algorithm": "linear", + "a": 0.4046856, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 91, + "fromAbbr": "mM", + "toAbbr": "mm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 92, + "fromAbbr": "mM^2", + "toAbbr": "M^2", + "algorithm": "linear", + "a": 0.000001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 93, + "fromAbbr": "kpa", + "toAbbr": "pa", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 94, + "fromAbbr": "ft*lbf/s", + "toAbbr": "W", + "algorithm": "linear", + "a": 1.355818, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 95, + "fromAbbr": "mmHg", + "toAbbr": "pa", + "algorithm": "linear", + "a": 133.3224, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 96, + "fromAbbr": "%", + "toAbbr": "ppt", + "algorithm": "linear", + "a": 10, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 97, + "fromAbbr": "lb", + "toAbbr": "G", + "algorithm": "linear", + "a": 453.59237, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 98, + "fromAbbr": "gal", + "toAbbr": "in^3", + "algorithm": "linear", + "a": 231, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 99, + "fromAbbr": "inHg", + "toAbbr": "in-hg", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 100, + "fromAbbr": "ft^2", + "toAbbr": "in^2", + "algorithm": "linear", + "a": 144, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 101, + "fromAbbr": "ton", + "toAbbr": "lb", + "algorithm": "linear", + "a": 2000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 102, + "fromAbbr": "M^3", + "toAbbr": "m3", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 103, + "fromAbbr": "mi^2", + "toAbbr": "acre", + "algorithm": "linear", + "a": 640, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 104, + "fromAbbr": "mbar", + "toAbbr": "mb", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 105, + "fromAbbr": "mt", + "toAbbr": "G", + "algorithm": "linear", + "a": 1000000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 106, + "fromAbbr": "GWh", + "toAbbr": "TWh", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 107, + "fromAbbr": "kM/hr", + "toAbbr": "kph", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 108, + "fromAbbr": "degF", + "toAbbr": "F", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 109, + "fromAbbr": "mM/s", + "toAbbr": "mm/hr", + "algorithm": "linear", + "a": 3600, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 110, + "fromAbbr": "uS/cm", + "toAbbr": "umho/cm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 111, + "fromAbbr": "km3", + "toAbbr": "mile3", + "algorithm": "linear", + "a": 0.2399128, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 112, + "fromAbbr": "kj", + "toAbbr": "Wh", + "algorithm": "linear", + "a": 0.2777778, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 113, + "fromAbbr": "M/s", + "toAbbr": "cM/s", + "algorithm": "linear", + "a": 100, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 114, + "fromAbbr": "dyn", + "toAbbr": "N", + "algorithm": "linear", + "a": 0.00001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 115, + "fromAbbr": "hr", + "toAbbr": "min", + "algorithm": "linear", + "a": 60, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 116, + "fromAbbr": "ft^2", + "toAbbr": "M^2", + "algorithm": "linear", + "a": 0.09290304, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 117, + "fromAbbr": "g/L", + "toAbbr": "g/l", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 118, + "fromAbbr": "hp", + "toAbbr": "W", + "algorithm": "linear", + "a": 746, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 119, + "fromAbbr": "mm/hr", + "toAbbr": "mm/day", + "algorithm": "linear", + "a": 24, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 120, + "fromAbbr": "day", + "toAbbr": "hr", + "algorithm": "linear", + "a": 24, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 121, + "fromAbbr": "j", + "toAbbr": "erg", + "algorithm": "linear", + "a": 10000000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 122, + "fromAbbr": "mph", + "toAbbr": "mi/hr", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 123, + "fromAbbr": "uMHOs/cm", + "toAbbr": "umho/cm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 124, + "fromAbbr": "pH", + "toAbbr": "su", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 125, + "fromAbbr": "mG/L", + "toAbbr": "mg/l", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 126, + "fromAbbr": "acre*ft", + "toAbbr": "ft^3", + "algorithm": "linear", + "a": 43560, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 127, + "fromAbbr": "degC", + "toAbbr": "degK", + "algorithm": "linear", + "a": 1, + "b": 273.15, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 128, + "fromAbbr": "kcal", + "toAbbr": "cal", + "algorithm": "linear", + "a": 1000, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 129, + "fromAbbr": "degC", + "toAbbr": "C", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 130, + "fromAbbr": "degC", + "toAbbr": "degF", + "algorithm": "linear", + "a": 1.8, + "b": 32, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 131, + "fromAbbr": "umho", + "toAbbr": "uS", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 132, + "fromAbbr": "m3", + "toAbbr": "1000 m3", + "algorithm": "linear", + "a": 0.001, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 133, + "fromAbbr": "yd/s", + "toAbbr": "ft/s", + "algorithm": "linear", + "a": 3, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 134, + "fromAbbr": "nmi", + "toAbbr": "m", + "algorithm": "linear", + "a": 1852, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + }, + { + "ucId": 135, + "fromAbbr": "mG/L", + "toAbbr": "ppm", + "algorithm": "none", + "a": 0, + "b": 0, + "c": 0, + "d": 0, + "e": 0, + "f": 0 + } +] \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected.json new file mode 100644 index 000000000..1abb016d2 --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected.json @@ -0,0 +1,1844 @@ +[ + { + "id": 1, + "standard": "CWMS", + "code": "Height", + "displayName": "CWMS:Height" + }, + { + "id": 2, + "standard": "CWMS", + "code": "Opening-Tainters", + "displayName": "CWMS:Opening-Tainters" + }, + { + "id": 3, + "standard": "NRCS", + "code": "WDMV", + "displayName": "WIND MOVEMENT OBSERVED" + }, + { + "id": 4, + "standard": "SHEF-PE", + "code": "QY", + "displayName": "SHEF-PE:QY" + }, + { + "id": 5, + "standard": "NRCS", + "code": "COND", + "displayName": "CONDUCTIVITY" + }, + { + "id": 6, + "standard": "SHEF-PE", + "code": "QV", + "displayName": "SHEF-PE:QV" + }, + { + "id": 7, + "standard": "SHEF-PE", + "code": "QU", + "displayName": "SHEF-PE:QU" + }, + { + "id": 8, + "standard": "SHEF-PE", + "code": "QT", + "displayName": "SHEF-PE:QT" + }, + { + "id": 9, + "standard": "CWMS", + "code": "Power", + "displayName": "CWMS:Power" + }, + { + "id": 10, + "standard": "SHEF-PE", + "code": "QS", + "displayName": "SHEF-PE:QS" + }, + { + "id": 11, + "standard": "EPA-CODE", + "code": "00076", + "displayName": "EPA-CODE:00076" + }, + { + "id": 12, + "standard": "SHEF-PE", + "code": "QR", + "displayName": "SHEF-PE:QR" + }, + { + "id": 13, + "standard": "NRCS", + "code": "SRADN", + "displayName": "SOLAR RADIATION MINIMUM" + }, + { + "id": 14, + "standard": "NRCS", + "code": "SRADT", + "displayName": "SOLAR RADIATION TOTAL" + }, + { + "id": 15, + "standard": "SHEF-PE", + "code": "BA", + "displayName": "SHEF-PE:BA" + }, + { + "id": 16, + "standard": "CWMS", + "code": "Speed-Wind", + "displayName": "CWMS:Speed-Wind" + }, + { + "id": 17, + "standard": "NRCS", + "code": "SRADX", + "displayName": "SOLAR RADIATION MAXIMUM" + }, + { + "id": 18, + "standard": "NRCS", + "code": "WDMVV", + "displayName": "WIND MOVEMENT AVERAGE" + }, + { + "id": 19, + "standard": "NRCS", + "code": "SRADV", + "displayName": "SOLAR RADIATION AVERAGE" + }, + { + "id": 20, + "standard": "NRCS", + "code": "WDMVX", + "displayName": "WIND MOVEMENT MAXIMUM" + }, + { + "id": 21, + "standard": "SHEF-PE", + "code": "RF", + "displayName": "SHEF-PE:RF" + }, + { + "id": 22, + "standard": "CWMS", + "code": "Opening-East", + "displayName": "CWMS:Opening-East" + }, + { + "id": 23, + "standard": "SHEF-PE", + "code": "RE", + "displayName": "SHEF-PE:RE" + }, + { + "id": 24, + "standard": "EPA-CODE", + "code": "70969", + "displayName": "EPA-CODE:70969" + }, + { + "id": 25, + "standard": "NRCS", + "code": "LRADT", + "displayName": "SOLAR RADIATION/LANGLEY TOTAL" + }, + { + "id": 26, + "standard": "NRCS", + "code": "WDMVT", + "displayName": "WIND MOVEMENT TOTAL" + }, + { + "id": 27, + "standard": "NRCS", + "code": "WDMVN", + "displayName": "WIND MOVEMENT MINIMUM" + }, + { + "id": 28, + "standard": "SHEF-PE", + "code": "PR", + "displayName": "SHEF-PE:PR" + }, + { + "id": 29, + "standard": "NRCS", + "code": "LRADX", + "displayName": "SOLAR RADIATION/LANGLEY MAXIMUM" + }, + { + "id": 30, + "standard": "SHEF-PE", + "code": "PP", + "displayName": "SHEF-PE:PP" + }, + { + "id": 31, + "standard": "NRCS", + "code": "SMV", + "displayName": "SOIL MOISTURE BARS AVERAGE" + }, + { + "id": 32, + "standard": "SHEF-PE", + "code": "QP", + "displayName": "SHEF-PE:QP" + }, + { + "id": 33, + "standard": "CWMS", + "code": "Turb", + "displayName": "CWMS:Turb" + }, + { + "id": 34, + "standard": "NRCS", + "code": "SMX", + "displayName": "SOIL MOISTURE BARS MAXIMUM" + }, + { + "id": 35, + "standard": "SHEF-PE", + "code": "QN", + "displayName": "SHEF-PE:QN" + }, + { + "id": 36, + "standard": "SHEF-PE", + "code": "QM", + "displayName": "SHEF-PE:QM" + }, + { + "id": 37, + "standard": "SHEF-PE", + "code": "QL", + "displayName": "SHEF-PE:QL" + }, + { + "id": 38, + "standard": "EPA-CODE", + "code": "00400", + "displayName": "EPA-CODE:00400" + }, + { + "id": 39, + "standard": "NRCS", + "code": "SMS", + "displayName": "SOIL MOISTURE PERCENT" + }, + { + "id": 40, + "standard": "SHEF-PE", + "code": "QI", + "displayName": "SHEF-PE:QI" + }, + { + "id": 41, + "standard": "NRCS", + "code": "SMN", + "displayName": "SOIL MOISTURE BARS MINIMUM" + }, + { + "id": 42, + "standard": "CWMS", + "code": "Flow-Out", + "displayName": "CWMS:Flow-Out" + }, + { + "id": 43, + "standard": "NRCS", + "code": "SMO", + "displayName": "SOIL MOISTURE BARS OBSERVED" + }, + { + "id": 44, + "standard": "SHEF-PE", + "code": "QG", + "displayName": "SHEF-PE:QG" + }, + { + "id": 45, + "standard": "SHEF-PE", + "code": "QF", + "displayName": "SHEF-PE:QF" + }, + { + "id": 46, + "standard": "SHEF-PE", + "code": "QE", + "displayName": "SHEF-PE:QE" + }, + { + "id": 47, + "standard": "SHEF-PE", + "code": "QD", + "displayName": "SHEF-PE:QD" + }, + { + "id": 48, + "standard": "SHEF-PE", + "code": "QC", + "displayName": "SHEF-PE:QC" + }, + { + "id": 49, + "standard": "SHEF-PE", + "code": "QB", + "displayName": "SHEF-PE:QB" + }, + { + "id": 50, + "standard": "SHEF-PE", + "code": "QA", + "displayName": "SHEF-PE:QA" + }, + { + "id": 51, + "standard": "NRCS", + "code": "SRVOX", + "displayName": "STREAM VOLUME ADJUSTED EXTERNALLY" + }, + { + "id": 52, + "standard": "NRCS", + "code": "WTMIN", + "displayName": "WATER TEMPERATURE MINIMUM" + }, + { + "id": 53, + "standard": "CWMS", + "code": "Thick-Ice", + "displayName": "CWMS:Thick-Ice" + }, + { + "id": 54, + "standard": "SHEF-PE", + "code": "PL", + "displayName": "SHEF-PE:PL" + }, + { + "id": 55, + "standard": "NRCS", + "code": "FMTMP", + "displayName": "FUEL TEMPERATURE INTERNAL" + }, + { + "id": 56, + "standard": "SHEF-PE", + "code": "PF", + "displayName": "SHEF-PE:PF" + }, + { + "id": 57, + "standard": "SHEF-PE", + "code": "PE", + "displayName": "SHEF-PE:PE" + }, + { + "id": 58, + "standard": "SHEF-PE", + "code": "PD", + "displayName": "SHEF-PE:PD" + }, + { + "id": 59, + "standard": "SHEF-PE", + "code": "PC", + "displayName": "SHEF-PE:PC" + }, + { + "id": 60, + "standard": "SHEF-PE", + "code": "PA", + "displayName": "SHEF-PE:PA" + }, + { + "id": 61, + "standard": "NRCS", + "code": "JDAY", + "displayName": "JULIAN DATE" + }, + { + "id": 62, + "standard": "CWMS", + "code": "pH", + "displayName": "CWMS:pH" + }, + { + "id": 63, + "standard": "CWMS", + "code": "Elev-Pool", + "displayName": "CWMS:Elev-Pool" + }, + { + "id": 64, + "standard": "CWMS", + "code": "Rad", + "displayName": "CWMS:Rad" + }, + { + "id": 65, + "standard": "EPA-CODE", + "code": "00061", + "displayName": "EPA-CODE:00061" + }, + { + "id": 66, + "standard": "EPA-CODE", + "code": "00065", + "displayName": "EPA-CODE:00065" + }, + { + "id": 67, + "standard": "NRCS", + "code": "SRAD", + "displayName": "SOLAR RADIATION" + }, + { + "id": 68, + "standard": "HYDSTRA-CODE", + "code": "100", + "displayName": "HYDSTRA-CODE:100" + }, + { + "id": 69, + "standard": "NRCS", + "code": "WELL", + "displayName": "WELL DEPTH" + }, + { + "id": 70, + "standard": "NRCS", + "code": "WSPDN", + "displayName": "WIND SPEED MINIMUM" + }, + { + "id": 71, + "standard": "SHEF-PE", + "code": "MW", + "displayName": "SHEF-PE:MW" + }, + { + "id": 72, + "standard": "SHEF-PE", + "code": "MU", + "displayName": "SHEF-PE:MU" + }, + { + "id": 73, + "standard": "SHEF-PE", + "code": "MT", + "displayName": "SHEF-PE:MT" + }, + { + "id": 74, + "standard": "NRCS", + "code": "DISP", + "displayName": "DISSOLVED OXYGEN - PERCENT SATURATION" + }, + { + "id": 75, + "standard": "SHEF-PE", + "code": "MS", + "displayName": "SHEF-PE:MS" + }, + { + "id": 76, + "standard": "NRCS", + "code": "DISO", + "displayName": "DISSOLVED OXYGEN" + }, + { + "id": 77, + "standard": "SHEF-PE", + "code": "MM", + "displayName": "SHEF-PE:MM" + }, + { + "id": 78, + "standard": "NRCS", + "code": "WDIRV", + "displayName": "WIND DIRECTION AVERAGE" + }, + { + "id": 79, + "standard": "CWMS", + "code": "Timing", + "displayName": "CWMS:Timing" + }, + { + "id": 80, + "standard": "SHEF-PE", + "code": "NG", + "displayName": "SHEF-PE:NG" + }, + { + "id": 81, + "standard": "NRCS", + "code": "FUEL", + "displayName": "FUEL MOISTURE" + }, + { + "id": 82, + "standard": "NRCS", + "code": "SVPV", + "displayName": "VAPOR PRESSURE - SATURATED" + }, + { + "id": 83, + "standard": "HYDSTRA-CODE", + "code": "10", + "displayName": "HYDSTRA-CODE:10" + }, + { + "id": 84, + "standard": "NRCS", + "code": "NTRDX", + "displayName": "NET SOLAR RADIATION MAXIMUM" + }, + { + "id": 85, + "standard": "CWMS", + "code": "Temp-Air", + "displayName": "CWMS:Temp-Air" + }, + { + "id": 86, + "standard": "NRCS", + "code": "NTRDV", + "displayName": "NET SOLAR RADIATION AVERAGE" + }, + { + "id": 87, + "standard": "NRCS", + "code": "SRDOO", + "displayName": "RIVER DISCHARGE OBSERVED MEAN" + }, + { + "id": 88, + "standard": "SHEF-PE", + "code": "LS", + "displayName": "SHEF-PE:LS" + }, + { + "id": 89, + "standard": "NRCS", + "code": "NTRDN", + "displayName": "NET SOLAR RADIATION MINIMUM" + }, + { + "id": 90, + "standard": "NRCS", + "code": "SRDOX", + "displayName": "DISCHARGE MANUAL/EXTERNAL ADJUSTED MEAN" + }, + { + "id": 91, + "standard": "SHEF-PE", + "code": "ML", + "displayName": "SHEF-PE:ML" + }, + { + "id": 92, + "standard": "NRCS", + "code": "SAL", + "displayName": "SALINITY" + }, + { + "id": 93, + "standard": "NRCS", + "code": "SNOW", + "displayName": "SNOW FALL" + }, + { + "id": 94, + "standard": "SHEF-PE", + "code": "MI", + "displayName": "SHEF-PE:MI" + }, + { + "id": 95, + "standard": "NRCS", + "code": "NTRDC", + "displayName": "NET SOLAR RADIATION OBSERVED" + }, + { + "id": 96, + "standard": "NRCS", + "code": "DIAG", + "displayName": "DIAGNOSTICS" + }, + { + "id": 97, + "standard": "NRCS", + "code": "H2OPH", + "displayName": "PH" + }, + { + "id": 98, + "standard": "NRCS", + "code": "WTAVG", + "displayName": "WATER TEMPERATURE AVERAGE" + }, + { + "id": 99, + "standard": "CWMS", + "code": "Stage", + "displayName": "CWMS:Stage" + }, + { + "id": 100, + "standard": "EPA-CODE", + "code": "00096", + "displayName": "EPA-CODE:00096" + }, + { + "id": 101, + "standard": "NRCS", + "code": "PRCPSA", + "displayName": "PRECIPITATION INCREMENT – SNOW-ADJUSTED" + }, + { + "id": 102, + "standard": "EPA-CODE", + "code": "00095", + "displayName": "EPA-CODE:00095" + }, + { + "id": 103, + "standard": "CWMS", + "code": "Opening-Rollers", + "displayName": "CWMS:Opening-Rollers" + }, + { + "id": 104, + "standard": "CWMS", + "code": "Flow", + "displayName": "CWMS:Flow" + }, + { + "id": 105, + "standard": "NRCS", + "code": "WTEMP", + "displayName": "WATER TEMPERATURE" + }, + { + "id": 106, + "standard": "SHEF-PE", + "code": "LC", + "displayName": "SHEF-PE:LC" + }, + { + "id": 107, + "standard": "SHEF-PE", + "code": "LA", + "displayName": "SHEF-PE:LA" + }, + { + "id": 108, + "standard": "CWMS", + "code": "Flow-In", + "displayName": "CWMS:Flow-In" + }, + { + "id": 109, + "standard": "NRCS", + "code": "SRVO", + "displayName": "STREAM VOLUME OBSERVED" + }, + { + "id": 110, + "standard": "NRCS", + "code": "TMIN", + "displayName": "AIR TEMPERATURE MINIMUM" + }, + { + "id": 111, + "standard": "NRCS", + "code": "RHUMN", + "displayName": "RELATIVE HUMIDITY MINIMUM" + }, + { + "id": 112, + "standard": "EPA-CODE", + "code": "00300", + "displayName": "EPA-CODE:00300" + }, + { + "id": 113, + "standard": "CWMS", + "code": "Depth-Snowwater", + "displayName": "CWMS:Depth-Snowwater" + }, + { + "id": 114, + "standard": "NRCS", + "code": "WSPDX", + "displayName": "WIND SPEED MAXIMUM" + }, + { + "id": 115, + "standard": "NRCS", + "code": "RHENC", + "displayName": "RELATIVE HUMIDITY ENCLOSURE" + }, + { + "id": 116, + "standard": "NRCS", + "code": "SRVA", + "displayName": "STREAM VOLUME ADJUSTED" + }, + { + "id": 117, + "standard": "NRCS", + "code": "RHUMV", + "displayName": "RELATIVE HUMIDITY AVERAGE" + }, + { + "id": 118, + "standard": "NRCS", + "code": "RHUMX", + "displayName": "RELATIVE HUMIDITY MAXIMUM" + }, + { + "id": 119, + "standard": "NRCS", + "code": "WSPDV", + "displayName": "WIND SPEED AVERAGE" + }, + { + "id": 120, + "standard": "NRCS", + "code": "RHUM", + "displayName": "RELATIVE HUMIDITY" + }, + { + "id": 121, + "standard": "NRCS", + "code": "PRES", + "displayName": "BAROMETRIC PRESSURE" + }, + { + "id": 122, + "standard": "NRCS", + "code": "STN", + "displayName": "SOIL TEMPERATURE MINIMUM" + }, + { + "id": 123, + "standard": "NRCS", + "code": "STO", + "displayName": "SOIL TEMPERATURE OBSERVED" + }, + { + "id": 124, + "standard": "SHEF-PE", + "code": "IT", + "displayName": "SHEF-PE:IT" + }, + { + "id": 125, + "standard": "NRCS", + "code": "LRAD", + "displayName": "SOLAR RADIATION/LANGLEY" + }, + { + "id": 126, + "standard": "NRCS", + "code": "PREC", + "displayName": "PRECIPITATION ACCUMULATION" + }, + { + "id": 127, + "standard": "CWMS", + "code": "Ratio", + "displayName": "CWMS:Ratio" + }, + { + "id": 128, + "standard": "NRCS", + "code": "STV", + "displayName": "SOIL TEMPERATURE AVERAGE" + }, + { + "id": 129, + "standard": "NRCS", + "code": "STX", + "displayName": "SOIL TEMPERATURE MAXIMUM" + }, + { + "id": 130, + "standard": "SHEF-PE", + "code": "HW", + "displayName": "SHEF-PE:HW" + }, + { + "id": 131, + "standard": "SHEF-PE", + "code": "HU", + "displayName": "SHEF-PE:HU" + }, + { + "id": 132, + "standard": "SHEF-PE", + "code": "HT", + "displayName": "SHEF-PE:HT" + }, + { + "id": 133, + "standard": "NRCS", + "code": "ETIB", + "displayName": "BATTERY-ETI PRECIP GAGE" + }, + { + "id": 134, + "standard": "NRCS", + "code": "DPTP", + "displayName": "DEW POINT TEMPERATURE" + }, + { + "id": 135, + "standard": "NRCS", + "code": "TGSV", + "displayName": "GROUND SURFACE INTERFACE TEMPERATURE AVERAGE" + }, + { + "id": 136, + "standard": "SHEF-PE", + "code": "HS", + "displayName": "SHEF-PE:HS" + }, + { + "id": 137, + "standard": "SHEF-PE", + "code": "HR", + "displayName": "SHEF-PE:HR" + }, + { + "id": 138, + "standard": "CWMS", + "code": "Rotation", + "displayName": "CWMS:Rotation" + }, + { + "id": 139, + "standard": "SHEF-PE", + "code": "HQ", + "displayName": "SHEF-PE:HQ" + }, + { + "id": 140, + "standard": "SHEF-PE", + "code": "HP", + "displayName": "SHEF-PE:HP" + }, + { + "id": 141, + "standard": "NRCS", + "code": "SNWDN", + "displayName": "SNOW DEPTH MINIMUM" + }, + { + "id": 142, + "standard": "NRCS", + "code": "WLEVV", + "displayName": "WATER LEVEL AVERAGE" + }, + { + "id": 143, + "standard": "SHEF-PE", + "code": "HO", + "displayName": "SHEF-PE:HO" + }, + { + "id": 144, + "standard": "SHEF-PE", + "code": "HN", + "displayName": "SHEF-PE:HN" + }, + { + "id": 145, + "standard": "NRCS", + "code": "TGSX", + "displayName": "GROUND SURFACE INTERFACE TEMPERATURE MAXIMUM" + }, + { + "id": 146, + "standard": "NRCS", + "code": "WLEVX", + "displayName": "WATER LEVEL MAXIMUM" + }, + { + "id": 147, + "standard": "SHEF-PE", + "code": "HM", + "displayName": "SHEF-PE:HM" + }, + { + "id": 148, + "standard": "SHEF-PE", + "code": "HL", + "displayName": "SHEF-PE:HL" + }, + { + "id": 149, + "standard": "NRCS", + "code": "HFTV", + "displayName": "ENERGY GAIN OR LOSS FROM GROUND" + }, + { + "id": 150, + "standard": "SHEF-PE", + "code": "HK", + "displayName": "SHEF-PE:HK" + }, + { + "id": 151, + "standard": "SHEF-PE", + "code": "HJ", + "displayName": "SHEF-PE:HJ" + }, + { + "id": 152, + "standard": "SHEF-PE", + "code": "HH", + "displayName": "SHEF-PE:HH" + }, + { + "id": 153, + "standard": "NRCS", + "code": "SNWDV", + "displayName": "SNOW DEPTH AVERAGE" + }, + { + "id": 154, + "standard": "NRCS", + "code": "WLEVN", + "displayName": "WATER LEVEL MINIMUM" + }, + { + "id": 155, + "standard": "CWMS", + "code": "SpinRate", + "displayName": "CWMS:SpinRate" + }, + { + "id": 156, + "standard": "NRCS", + "code": "SNWDX", + "displayName": "SNOW DEPTH MAXIMUM" + }, + { + "id": 157, + "standard": "SHEF-PE", + "code": "IC", + "displayName": "SHEF-PE:IC" + }, + { + "id": 158, + "standard": "NRCS", + "code": "ETIL", + "displayName": "PULSE LINE MONITOR-ETI GUAGE" + }, + { + "id": 159, + "standard": "NRCS", + "code": "TGSI", + "displayName": "GROUND SURFACE INTERFACE TEMPERATURE OBSERVED" + }, + { + "id": 160, + "standard": "NRCS", + "code": "TGSN", + "displayName": "GROUND SURFACE INTERFACE TEMPERATURE MINIMUM" + }, + { + "id": 161, + "standard": "SHEF-PE", + "code": "HZ", + "displayName": "SHEF-PE:HZ" + }, + { + "id": 162, + "standard": "NRCS", + "code": "TOBS", + "displayName": "AIR TEMPERATURE OBSERVED" + }, + { + "id": 163, + "standard": "SHEF-PE", + "code": "HY", + "displayName": "SHEF-PE:HY" + }, + { + "id": 164, + "standard": "SHEF-PE", + "code": "HX", + "displayName": "SHEF-PE:HX" + }, + { + "id": 165, + "standard": "NRCS", + "code": "PARV", + "displayName": "PHOTOSYNTHETICALLY ACTIVE RADIATION (PAR) AVERAGE" + }, + { + "id": 166, + "standard": "CWMS", + "code": "Travel", + "displayName": "CWMS:Travel" + }, + { + "id": 167, + "standard": "SHEF-PE", + "code": "HG", + "displayName": "SHEF-PE:HG" + }, + { + "id": 168, + "standard": "NRCS", + "code": "OI", + "displayName": "TELECONNECTION INDEX (also known as OSCILLATION INDEX)" + }, + { + "id": 169, + "standard": "NRCS", + "code": "WTEQV", + "displayName": "SNOW WATER EQUIVALENT AVERAGE" + }, + { + "id": 170, + "standard": "SHEF-PE", + "code": "HF", + "displayName": "SHEF-PE:HF" + }, + { + "id": 171, + "standard": "SHEF-PE", + "code": "HE", + "displayName": "SHEF-PE:HE" + }, + { + "id": 172, + "standard": "NRCS", + "code": "WTEQX", + "displayName": "SNOW WATER EQUIVALENT MAXIMUM" + }, + { + "id": 173, + "standard": "SHEF-PE", + "code": "HD", + "displayName": "SHEF-PE:HD" + }, + { + "id": 174, + "standard": "SHEF-PE", + "code": "HC", + "displayName": "SHEF-PE:HC" + }, + { + "id": 175, + "standard": "SHEF-PE", + "code": "HB", + "displayName": "SHEF-PE:HB" + }, + { + "id": 176, + "standard": "CWMS", + "code": "TurbF", + "displayName": "CWMS:TurbF" + }, + { + "id": 177, + "standard": "SHEF-PE", + "code": "HA", + "displayName": "SHEF-PE:HA" + }, + { + "id": 178, + "standard": "CWMS", + "code": "Temp", + "displayName": "CWMS:Temp" + }, + { + "id": 179, + "standard": "NRCS", + "code": "DIVD", + "displayName": "DIVERSION DISCHARGE OBSERVED MEAN" + }, + { + "id": 180, + "standard": "NRCS", + "code": "WTEQN", + "displayName": "SNOW WATER EQUIVALENT min" + }, + { + "id": 181, + "standard": "CWMS", + "code": "TurbJ", + "displayName": "CWMS:TurbJ" + }, + { + "id": 182, + "standard": "CWMS", + "code": "Depth-Snow", + "displayName": "CWMS:Depth-Snow" + }, + { + "id": 183, + "standard": "CWMS", + "code": "TurbN", + "displayName": "CWMS:TurbN" + }, + { + "id": 184, + "standard": "NRCS", + "code": "PRCP", + "displayName": "PRECIPITATION INCREMENT" + }, + { + "id": 185, + "standard": "CWMS", + "code": "Speed-Water", + "displayName": "CWMS:Speed-Water" + }, + { + "id": 186, + "standard": "SHEF-PE", + "code": "WC", + "displayName": "SHEF-PE:WC" + }, + { + "id": 187, + "standard": "NRCS", + "code": "WSPD", + "displayName": "WIND SPEED OBSERVED" + }, + { + "id": 188, + "standard": "NRCS", + "code": "REST", + "displayName": "RESERVOIR STAGE" + }, + { + "id": 189, + "standard": "SHEF-PE", + "code": "WA", + "displayName": "SHEF-PE:WA" + }, + { + "id": 190, + "standard": "NRCS", + "code": "TAVG", + "displayName": "AIR TEMPERATURE AVERAGE" + }, + { + "id": 191, + "standard": "NRCS", + "code": "RESA", + "displayName": "USABLE LAKE STORAGE VOLUME" + }, + { + "id": 192, + "standard": "SHEF-PE", + "code": "WV", + "displayName": "SHEF-PE:WV" + }, + { + "id": 193, + "standard": "NRCS", + "code": "RESC", + "displayName": "RESERVOIR STORAGE VOLUME" + }, + { + "id": 194, + "standard": "SHEF-PE", + "code": "GD", + "displayName": "SHEF-PE:GD" + }, + { + "id": 195, + "standard": "SHEF-PE", + "code": "WT", + "displayName": "SHEF-PE:WT" + }, + { + "id": 196, + "standard": "CWMS", + "code": "Speed", + "displayName": "CWMS:Speed" + }, + { + "id": 197, + "standard": "SHEF-PE", + "code": "WP", + "displayName": "SHEF-PE:WP" + }, + { + "id": 198, + "standard": "SHEF-PE", + "code": "WO", + "displayName": "SHEF-PE:WO" + }, + { + "id": 199, + "standard": "SHEF-PE", + "code": "WL", + "displayName": "SHEF-PE:WL" + }, + { + "id": 200, + "standard": "SHEF-PE", + "code": "WH", + "displayName": "SHEF-PE:WH" + }, + { + "id": 201, + "standard": "SHEF-PE", + "code": "WG", + "displayName": "SHEF-PE:WG" + }, + { + "id": 202, + "standard": "CWMS", + "code": "Volume", + "displayName": "CWMS:Volume" + }, + { + "id": 203, + "standard": "SHEF-PE", + "code": "ER", + "displayName": "SHEF-PE:ER" + }, + { + "id": 204, + "standard": "SHEF-PE", + "code": "VB", + "displayName": "SHEF-PE:VB" + }, + { + "id": 205, + "standard": "CWMS", + "code": "Volt", + "displayName": "CWMS:Volt" + }, + { + "id": 206, + "standard": "NRCS", + "code": "WDIR", + "displayName": "WIND DIRECTION OBSERVED" + }, + { + "id": 207, + "standard": "CWMS", + "code": "Stor", + "displayName": "CWMS:Stor" + }, + { + "id": 208, + "standard": "SHEF-PE", + "code": "UY", + "displayName": "SHEF-PE:UY" + }, + { + "id": 209, + "standard": "NRCS", + "code": "EVAP", + "displayName": "EVAPORATION" + }, + { + "id": 210, + "standard": "SHEF-PE", + "code": "UX", + "displayName": "SHEF-PE:UX" + }, + { + "id": 211, + "standard": "EPA-CODE", + "code": "00036", + "displayName": "EPA-CODE:00036" + }, + { + "id": 212, + "standard": "EPA-CODE", + "code": "00035", + "displayName": "EPA-CODE:00035" + }, + { + "id": 213, + "standard": "SHEF-PE", + "code": "VP", + "displayName": "SHEF-PE:VP" + }, + { + "id": 214, + "standard": "SHEF-PE", + "code": "UD", + "displayName": "SHEF-PE:UD" + }, + { + "id": 215, + "standard": "CWMS", + "code": "Thick", + "displayName": "CWMS:Thick" + }, + { + "id": 216, + "standard": "SHEF-PE", + "code": "UC", + "displayName": "SHEF-PE:UC" + }, + { + "id": 217, + "standard": "CWMS", + "code": "Opening", + "displayName": "CWMS:Opening" + }, + { + "id": 218, + "standard": "CWMS", + "code": "Opening-Wickets", + "displayName": "CWMS:Opening-Wickets" + }, + { + "id": 219, + "standard": "SHEF-PE", + "code": "TX", + "displayName": "SHEF-PE:TX" + }, + { + "id": 220, + "standard": "SHEF-PE", + "code": "TW", + "displayName": "SHEF-PE:TW" + }, + { + "id": 221, + "standard": "EPA-CODE", + "code": "00045", + "displayName": "EPA-CODE:00045" + }, + { + "id": 222, + "standard": "SHEF-PE", + "code": "US", + "displayName": "SHEF-PE:US" + }, + { + "id": 223, + "standard": "EPA-CODE", + "code": "00047", + "displayName": "EPA-CODE:00047" + }, + { + "id": 224, + "standard": "CWMS", + "code": "Elev-Tail", + "displayName": "CWMS:Elev-Tail" + }, + { + "id": 225, + "standard": "SHEF-PE", + "code": "UR", + "displayName": "SHEF-PE:UR" + }, + { + "id": 226, + "standard": "SHEF-PE", + "code": "EA", + "displayName": "SHEF-PE:EA" + }, + { + "id": 227, + "standard": "EPA-CODE", + "code": "99772", + "displayName": "EPA-CODE:99772" + }, + { + "id": 228, + "standard": "SHEF-PE", + "code": "UL", + "displayName": "SHEF-PE:UL" + }, + { + "id": 229, + "standard": "CWMS", + "code": "Temp-Water", + "displayName": "CWMS:Temp-Water" + }, + { + "id": 230, + "standard": "NRCS", + "code": "WTMAX", + "displayName": "WATER TEMPERATURE MAXIMUM" + }, + { + "id": 231, + "standard": "NRCS", + "code": "PVPV", + "displayName": "VAPOR PRESSURE - PARTIAL" + }, + { + "id": 232, + "standard": "SHEF-PE", + "code": "UG", + "displayName": "SHEF-PE:UG" + }, + { + "id": 233, + "standard": "SHEF-PE", + "code": "UF", + "displayName": "SHEF-PE:UF" + }, + { + "id": 234, + "standard": "SHEF-PE", + "code": "TC", + "displayName": "SHEF-PE:TC" + }, + { + "id": 235, + "standard": "SHEF-PE", + "code": "CR", + "displayName": "SHEF-PE:CR" + }, + { + "id": 236, + "standard": "SHEF-PE", + "code": "CQ", + "displayName": "SHEF-PE:CQ" + }, + { + "id": 237, + "standard": "SHEF-PE", + "code": "TA", + "displayName": "SHEF-PE:TA" + }, + { + "id": 238, + "standard": "NRCS", + "code": "TMAX", + "displayName": "AIR TEMPERATURE MAXIMUM" + }, + { + "id": 239, + "standard": "SHEF-PE", + "code": "CP", + "displayName": "SHEF-PE:CP" + }, + { + "id": 240, + "standard": "NRCS", + "code": "TURB", + "displayName": "TURBIDITY" + }, + { + "id": 241, + "standard": "CWMS", + "code": "Precip", + "displayName": "CWMS:Precip" + }, + { + "id": 242, + "standard": "SHEF-PE", + "code": "CN", + "displayName": "SHEF-PE:CN" + }, + { + "id": 243, + "standard": "SHEF-PE", + "code": "CM", + "displayName": "SHEF-PE:CM" + }, + { + "id": 244, + "standard": "SHEF-PE", + "code": "CL", + "displayName": "SHEF-PE:CL" + }, + { + "id": 245, + "standard": "SHEF-PE", + "code": "CK", + "displayName": "SHEF-PE:CK" + }, + { + "id": 246, + "standard": "SHEF-PE", + "code": "CJ", + "displayName": "SHEF-PE:CJ" + }, + { + "id": 247, + "standard": "SHEF-PE", + "code": "CI", + "displayName": "SHEF-PE:CI" + }, + { + "id": 248, + "standard": "SHEF-PE", + "code": "CH", + "displayName": "SHEF-PE:CH" + }, + { + "id": 249, + "standard": "EPA-CODE", + "code": "99065", + "displayName": "EPA-CODE:99065" + }, + { + "id": 250, + "standard": "SHEF-PE", + "code": "CG", + "displayName": "SHEF-PE:CG" + }, + { + "id": 251, + "standard": "SHEF-PE", + "code": "CF", + "displayName": "SHEF-PE:CF" + }, + { + "id": 252, + "standard": "SHEF-PE", + "code": "CE", + "displayName": "SHEF-PE:CE" + }, + { + "id": 253, + "standard": "EPA-CODE", + "code": "00010", + "displayName": "EPA-CODE:00010" + }, + { + "id": 254, + "standard": "SHEF-PE", + "code": "CD", + "displayName": "SHEF-PE:CD" + }, + { + "id": 255, + "standard": "SHEF-PE", + "code": "CC", + "displayName": "SHEF-PE:CC" + }, + { + "id": 256, + "standard": "SHEF-PE", + "code": "TS", + "displayName": "SHEF-PE:TS" + }, + { + "id": 257, + "standard": "SHEF-PE", + "code": "TP", + "displayName": "SHEF-PE:TP" + }, + { + "id": 258, + "standard": "SHEF-PE", + "code": "TN", + "displayName": "SHEF-PE:TN" + }, + { + "id": 259, + "standard": "CWMS", + "code": "Opening-West", + "displayName": "CWMS:Opening-West" + }, + { + "id": 260, + "standard": "SHEF-PE", + "code": "TM", + "displayName": "SHEF-PE:TM" + }, + { + "id": 261, + "standard": "NRCS", + "code": "STRV", + "displayName": "STRM FLOW AVERAGE" + }, + { + "id": 262, + "standard": "CWMS", + "code": "Stage-Tail", + "displayName": "CWMS:Stage-Tail" + }, + { + "id": 263, + "standard": "NRCS", + "code": "SNWD", + "displayName": "SNOW DEPTH" + }, + { + "id": 264, + "standard": "SHEF-PE", + "code": "TI", + "displayName": "SHEF-PE:TI" + }, + { + "id": 265, + "standard": "SHEF-PE", + "code": "CW", + "displayName": "SHEF-PE:CW" + }, + { + "id": 266, + "standard": "SHEF-PE", + "code": "TH", + "displayName": "SHEF-PE:TH" + }, + { + "id": 267, + "standard": "SHEF-PE", + "code": "CV", + "displayName": "SHEF-PE:CV" + }, + { + "id": 268, + "standard": "NRCS", + "code": "RDC", + "displayName": "REAL DIELECTRIC CONSTANT" + }, + { + "id": 269, + "standard": "SHEF-PE", + "code": "CU", + "displayName": "SHEF-PE:CU" + }, + { + "id": 270, + "standard": "SHEF-PE", + "code": "TF", + "displayName": "SHEF-PE:TF" + }, + { + "id": 271, + "standard": "SHEF-PE", + "code": "CS", + "displayName": "SHEF-PE:CS" + }, + { + "id": 272, + "standard": "SHEF-PE", + "code": "TD", + "displayName": "SHEF-PE:TD" + }, + { + "id": 273, + "standard": "SHEF-PE", + "code": "BQ", + "displayName": "SHEF-PE:BQ" + }, + { + "id": 274, + "standard": "SHEF-PE", + "code": "BP", + "displayName": "SHEF-PE:BP" + }, + { + "id": 275, + "standard": "SHEF-PE", + "code": "BO", + "displayName": "SHEF-PE:BO" + }, + { + "id": 276, + "standard": "SHEF-PE", + "code": "BN", + "displayName": "SHEF-PE:BN" + }, + { + "id": 277, + "standard": "SHEF-PE", + "code": "BM", + "displayName": "SHEF-PE:BM" + }, + { + "id": 278, + "standard": "SHEF-PE", + "code": "BL", + "displayName": "SHEF-PE:BL" + }, + { + "id": 279, + "standard": "SHEF-PE", + "code": "BK", + "displayName": "SHEF-PE:BK" + }, + { + "id": 280, + "standard": "SHEF-PE", + "code": "BJ", + "displayName": "SHEF-PE:BJ" + }, + { + "id": 281, + "standard": "SHEF-PE", + "code": "BI", + "displayName": "SHEF-PE:BI" + }, + { + "id": 282, + "standard": "SHEF-PE", + "code": "BH", + "displayName": "SHEF-PE:BH" + }, + { + "id": 283, + "standard": "SHEF-PE", + "code": "BG", + "displayName": "SHEF-PE:BG" + }, + { + "id": 284, + "standard": "CWMS", + "code": "Irrad", + "displayName": "CWMS:Irrad" + }, + { + "id": 285, + "standard": "SHEF-PE", + "code": "BF", + "displayName": "SHEF-PE:BF" + }, + { + "id": 286, + "standard": "SHEF-PE", + "code": "BE", + "displayName": "SHEF-PE:BE" + }, + { + "id": 287, + "standard": "SHEF-PE", + "code": "BD", + "displayName": "SHEF-PE:BD" + }, + { + "id": 288, + "standard": "CWMS", + "code": "Stage-Pool", + "displayName": "CWMS:Stage-Pool" + }, + { + "id": 289, + "standard": "SHEF-PE", + "code": "BC", + "displayName": "SHEF-PE:BC" + }, + { + "id": 290, + "standard": "EPA-CODE", + "code": "00020", + "displayName": "EPA-CODE:00020" + }, + { + "id": 291, + "standard": "SHEF-PE", + "code": "BB", + "displayName": "SHEF-PE:BB" + }, + { + "id": 292, + "standard": "HYDSTRA-CODE", + "code": "300", + "displayName": "HYDSTRA-CODE:300" + }, + { + "id": 293, + "standard": "SHEF-PE", + "code": "CB", + "displayName": "SHEF-PE:CB" + }, + { + "id": 294, + "standard": "CWMS", + "code": "Pres", + "displayName": "CWMS:Pres" + }, + { + "id": 295, + "standard": "SHEF-PE", + "code": "CA", + "displayName": "SHEF-PE:CA" + }, + { + "id": 296, + "standard": "SHEF-PE", + "code": "SP", + "displayName": "SHEF-PE:SP" + }, + { + "id": 297, + "standard": "NRCS", + "code": "SRMN", + "displayName": "STREAM STAGE (GAUGE HEIGHT) MINIMUM" + }, + { + "id": 298, + "standard": "NRCS", + "code": "SRMO", + "displayName": "STREAM STAGE (GAUGE HEIGHT) OBSERVED" + }, + { + "id": 299, + "standard": "SHEF-PE", + "code": "SN", + "displayName": "SHEF-PE:SN" + }, + { + "id": 300, + "standard": "NRCS", + "code": "WLEV", + "displayName": "WATER LEVEL OBSERVED" + }, + { + "id": 301, + "standard": "SHEF-PE", + "code": "SL", + "displayName": "SHEF-PE:SL" + }, + { + "id": 302, + "standard": "NRCS", + "code": "SRMX", + "displayName": "STREAM STAGE (GAUGE HEIGHT) MAXIMUM" + }, + { + "id": 303, + "standard": "NRCS", + "code": "WTEQ", + "displayName": "SNOW WATER EQUIVALENT" + }, + { + "id": 304, + "standard": "NRCS", + "code": "SRMV", + "displayName": "STREAM STAGE (GAUGE HEIGHT) AVERAGE" + }, + { + "id": 305, + "standard": "SHEF-PE", + "code": "BV", + "displayName": "SHEF-PE:BV" + }, + { + "id": 306, + "standard": "EPA-CODE", + "code": "99999", + "displayName": "EPA-CODE:99999" + }, + { + "id": 307, + "standard": "NRCS", + "code": "DIV", + "displayName": "DIVERSION FLOW VOLUME OBSERVED" + } +] \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected_filtered.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected_filtered.json new file mode 100644 index 000000000..b6ae698e6 --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_get_type_list_expected_filtered.json @@ -0,0 +1,260 @@ +[ + { + "id": 1, + "standard": "CWMS", + "code": "Height", + "displayName": "CWMS:Height" + }, + { + "id": 2, + "standard": "CWMS", + "code": "Opening-Tainters", + "displayName": "CWMS:Opening-Tainters" + }, + { + "id": 9, + "standard": "CWMS", + "code": "Power", + "displayName": "CWMS:Power" + }, + { + "id": 16, + "standard": "CWMS", + "code": "Speed-Wind", + "displayName": "CWMS:Speed-Wind" + }, + { + "id": 22, + "standard": "CWMS", + "code": "Opening-East", + "displayName": "CWMS:Opening-East" + }, + { + "id": 33, + "standard": "CWMS", + "code": "Turb", + "displayName": "CWMS:Turb" + }, + { + "id": 42, + "standard": "CWMS", + "code": "Flow-Out", + "displayName": "CWMS:Flow-Out" + }, + { + "id": 53, + "standard": "CWMS", + "code": "Thick-Ice", + "displayName": "CWMS:Thick-Ice" + }, + { + "id": 62, + "standard": "CWMS", + "code": "pH", + "displayName": "CWMS:pH" + }, + { + "id": 63, + "standard": "CWMS", + "code": "Elev-Pool", + "displayName": "CWMS:Elev-Pool" + }, + { + "id": 64, + "standard": "CWMS", + "code": "Rad", + "displayName": "CWMS:Rad" + }, + { + "id": 79, + "standard": "CWMS", + "code": "Timing", + "displayName": "CWMS:Timing" + }, + { + "id": 85, + "standard": "CWMS", + "code": "Temp-Air", + "displayName": "CWMS:Temp-Air" + }, + { + "id": 99, + "standard": "CWMS", + "code": "Stage", + "displayName": "CWMS:Stage" + }, + { + "id": 103, + "standard": "CWMS", + "code": "Opening-Rollers", + "displayName": "CWMS:Opening-Rollers" + }, + { + "id": 104, + "standard": "CWMS", + "code": "Flow", + "displayName": "CWMS:Flow" + }, + { + "id": 108, + "standard": "CWMS", + "code": "Flow-In", + "displayName": "CWMS:Flow-In" + }, + { + "id": 113, + "standard": "CWMS", + "code": "Depth-Snowwater", + "displayName": "CWMS:Depth-Snowwater" + }, + { + "id": 127, + "standard": "CWMS", + "code": "Ratio", + "displayName": "CWMS:Ratio" + }, + { + "id": 138, + "standard": "CWMS", + "code": "Rotation", + "displayName": "CWMS:Rotation" + }, + { + "id": 155, + "standard": "CWMS", + "code": "SpinRate", + "displayName": "CWMS:SpinRate" + }, + { + "id": 166, + "standard": "CWMS", + "code": "Travel", + "displayName": "CWMS:Travel" + }, + { + "id": 176, + "standard": "CWMS", + "code": "TurbF", + "displayName": "CWMS:TurbF" + }, + { + "id": 178, + "standard": "CWMS", + "code": "Temp", + "displayName": "CWMS:Temp" + }, + { + "id": 181, + "standard": "CWMS", + "code": "TurbJ", + "displayName": "CWMS:TurbJ" + }, + { + "id": 182, + "standard": "CWMS", + "code": "Depth-Snow", + "displayName": "CWMS:Depth-Snow" + }, + { + "id": 183, + "standard": "CWMS", + "code": "TurbN", + "displayName": "CWMS:TurbN" + }, + { + "id": 185, + "standard": "CWMS", + "code": "Speed-Water", + "displayName": "CWMS:Speed-Water" + }, + { + "id": 196, + "standard": "CWMS", + "code": "Speed", + "displayName": "CWMS:Speed" + }, + { + "id": 202, + "standard": "CWMS", + "code": "Volume", + "displayName": "CWMS:Volume" + }, + { + "id": 205, + "standard": "CWMS", + "code": "Volt", + "displayName": "CWMS:Volt" + }, + { + "id": 207, + "standard": "CWMS", + "code": "Stor", + "displayName": "CWMS:Stor" + }, + { + "id": 215, + "standard": "CWMS", + "code": "Thick", + "displayName": "CWMS:Thick" + }, + { + "id": 217, + "standard": "CWMS", + "code": "Opening", + "displayName": "CWMS:Opening" + }, + { + "id": 218, + "standard": "CWMS", + "code": "Opening-Wickets", + "displayName": "CWMS:Opening-Wickets" + }, + { + "id": 224, + "standard": "CWMS", + "code": "Elev-Tail", + "displayName": "CWMS:Elev-Tail" + }, + { + "id": 229, + "standard": "CWMS", + "code": "Temp-Water", + "displayName": "CWMS:Temp-Water" + }, + { + "id": 241, + "standard": "CWMS", + "code": "Precip", + "displayName": "CWMS:Precip" + }, + { + "id": 259, + "standard": "CWMS", + "code": "Opening-West", + "displayName": "CWMS:Opening-West" + }, + { + "id": 262, + "standard": "CWMS", + "code": "Stage-Tail", + "displayName": "CWMS:Stage-Tail" + }, + { + "id": 284, + "standard": "CWMS", + "code": "Irrad", + "displayName": "CWMS:Irrad" + }, + { + "id": 288, + "standard": "CWMS", + "code": "Stage-Pool", + "displayName": "CWMS:Stage-Pool" + }, + { + "id": 294, + "standard": "CWMS", + "code": "Pres", + "displayName": "CWMS:Pres" + } +] \ No newline at end of file diff --git a/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_insert_euconv_data.json b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_insert_euconv_data.json new file mode 100644 index 000000000..12d91fdae --- /dev/null +++ b/opendcs-rest-api/src/test/resources/org/opendcs/odcsapi/res/it/OPEN_TSDB/datatypeunit_insert_euconv_data.json @@ -0,0 +1,12 @@ +{ + "ucId" : null, + "fromAbbr" : "K", + "toAbbr" : "degC", + "algorithm" : "LINEAR", + "a" : 1.0, + "b" : -273.15, + "c" : null, + "d" : null, + "e" : null, + "f" : null +} \ No newline at end of file