diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java index 398f14eba..46e35c379 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/dao/DbException.java @@ -32,4 +32,9 @@ public DbException(String message, Exception cause) { super(message, cause); } + + public DbException(String message) + { + super(message); + } } diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/ComputationResources.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/ComputationResources.java index edb6e79ab..a03829d86 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/ComputationResources.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/ComputationResources.java @@ -15,10 +15,10 @@ package org.opendcs.odcsapi.res; -import java.sql.SQLException; -import java.util.logging.Logger; - +import java.util.ArrayList; +import java.util.stream.Collectors; 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; @@ -31,41 +31,119 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; +import decodes.db.DataType; +import decodes.db.Site; +import decodes.sql.DbKey; +import decodes.tsdb.CompRefFilter; +import decodes.tsdb.ConstraintException; +import decodes.tsdb.DbCompAlgorithm; +import decodes.tsdb.DbCompParm; +import decodes.tsdb.DbComputation; +import decodes.tsdb.DbIoException; +import decodes.tsdb.NoSuchObjectException; +import decodes.tsdb.TsGroup; +import decodes.tsdb.compedit.ComputationInList; +import opendcs.dai.ComputationDAI; +import org.opendcs.odcsapi.beans.ApiCompParm; import org.opendcs.odcsapi.beans.ApiComputation; -import org.opendcs.odcsapi.dao.ApiComputationDAO; +import org.opendcs.odcsapi.beans.ApiComputationRef; import org.opendcs.odcsapi.dao.DbException; -import org.opendcs.odcsapi.errorhandling.ErrorCodes; import org.opendcs.odcsapi.errorhandling.WebAppException; -import org.opendcs.odcsapi.hydrojson.DbInterface; import org.opendcs.odcsapi.sec.AuthorizationCheck; -import org.opendcs.odcsapi.util.ApiConstants; -import org.opendcs.odcsapi.util.ApiHttpUtil; @Path("/") -public class ComputationResources +public class ComputationResources extends OpenDcsResource { @Context HttpHeaders httpHeaders; - + @GET @Path("computationrefs") @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_GUEST}) public Response getComputationRefs(@QueryParam("site") String site, - @QueryParam("algorithm") String algorithm, - @QueryParam("datatype") String datatype, - @QueryParam("group") String group, - @QueryParam("process") String process, - @QueryParam("enabled") Boolean enabled, - @QueryParam("interval") String interval) - throws WebAppException, DbException + @QueryParam("algorithm") String algorithm, + @QueryParam("datatype") String datatype, + @QueryParam("group") String group, + @QueryParam("process") String process, + @QueryParam("enabled") Boolean enabled, + @QueryParam("interval") String interval) + throws DbException + { + try (ComputationDAI dai = getLegacyTimeseriesDB().makeComputationDAO()) + { + CompRefFilter refFilter = new CompRefFilter(); + if (enabled != null) + { + refFilter.setEnabledOnly(enabled); + } + if (algorithm != null) + { + refFilter.setAlgorithm(algorithm); + } + if (datatype != null) + { + refFilter.setDataType(datatype); + } + if (group != null) + { + refFilter.setGroup(group); + } + if (process != null) + { + refFilter.setProcess(process); + } + if (site != null) + { + refFilter.setSite(site); + } + if (interval != null) + { + refFilter.setIntervalCode(interval); + } + return Response.status(HttpServletResponse.SC_OK) + .entity(dai.listCompRefsForREST(refFilter) + .stream() + .map(ComputationResources::map) + .collect(Collectors.toList())) + .build(); + } + catch(DbIoException e) + { + throw new DbException("Unable to retrieve computation references", e); + } + } + + static ArrayList map(ArrayList computations) { - Logger.getLogger(ApiConstants.loggerName).fine("getComputationRefs"); - try (DbInterface dbi = new DbInterface(); - ApiComputationDAO dao = new ApiComputationDAO(dbi)) + ArrayList ret = new ArrayList<>(); + for (ComputationInList comp : computations) { - return ApiHttpUtil.createResponse(dao.getComputationRefs(site, algorithm, datatype, group, - process, enabled, interval)); + ApiComputationRef ref = new ApiComputationRef(); + ref.setComputationId(comp.getComputationId().getValue()); + if (comp.getAlgorithmId() != null) + { + ref.setAlgorithmId(comp.getAlgorithmId().getValue()); + } + else + { + ref.setAlgorithmId(DbKey.NullKey.getValue()); + } + ref.setAlgorithmName(comp.getAlgorithmName()); + ref.setName(comp.getComputationName()); + ref.setEnabled(comp.isEnabled()); + ref.setDescription(comp.getDescription()); + ref.setProcessName(comp.getProcessName()); + if (comp.getProcessId() != null) + { + ref.setProcessId(comp.getProcessId().getValue()); + } + else + { + ref.setProcessId(DbKey.NullKey.getValue()); + } + ret.add(ref); } + return ret; } @GET @@ -73,38 +151,236 @@ public Response getComputationRefs(@QueryParam("site") String site, @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_GUEST}) public Response getComputation(@QueryParam("computationid") Long compId) - throws WebAppException, DbException + throws WebAppException, DbException { if (compId == null) - throw new WebAppException(ErrorCodes.MISSING_ID, - "Missing required computationid parameter."); - - Logger.getLogger(ApiConstants.loggerName).fine("getComputation computationid=" + compId); + { + throw new WebAppException(HttpServletResponse.SC_BAD_REQUEST, + "Missing required computationid parameter."); + } - try (DbInterface dbi = new DbInterface(); - ApiComputationDAO dao = new ApiComputationDAO(dbi)) + try (ComputationDAI dai = getLegacyTimeseriesDB().makeComputationDAO()) { - return ApiHttpUtil.createResponse(dao.getComputation(compId)); + return Response.status(HttpServletResponse.SC_OK) + .entity(map(dai.getComputationById(DbKey.createDbKey(compId)))).build(); + } + catch(DbIoException e) + { + throw new DbException(String.format("Unable to retrieve computation by ID: %s", compId), e); + } + catch (NoSuchObjectException e) + { + throw new WebAppException(HttpServletResponse.SC_NOT_FOUND, + String.format("Computation with ID %s not found", compId)); } } - + static ApiComputation map(DbComputation comp) + { + ApiComputation ret = new ApiComputation(); + if (comp.getId() != null) + { + ret.setComputationId(comp.getId().getValue()); + } + else + { + ret.setComputationId(DbKey.NullKey.getValue()); + } + if (comp.getAlgorithmId() != null) + { + ret.setAlgorithmId(comp.getAlgorithmId().getValue()); + } + else + { + ret.setAlgorithmId(DbKey.NullKey.getValue()); + } + ret.setComment(comp.getComment()); + if (comp.getAppId() != null) + { + ret.setAppId(comp.getAppId().getValue()); + } + else + { + ret.setAppId(DbKey.NullKey.getValue()); + } + ret.setEnabled(comp.isEnabled()); + ret.setEffectiveEndDate(comp.getValidEnd()); + ret.setEffectiveStartDate(comp.getValidStart()); + ret.setAlgorithmName(comp.getAlgorithmName()); + ret.setApplicationName(comp.getApplicationName()); + ret.setGroupName(comp.getGroupName()); + ret.setName(comp.getName()); + ret.setLastModified(comp.getLastModified()); + if (comp.getGroupId() != null) + { + ret.setGroupId(comp.getGroupId().getValue()); + } + else + { + ret.setGroupId(DbKey.NullKey.getValue()); + } + ret.setProps(comp.getProperties()); + ret.setParmList(new ArrayList<>(comp.getParmList() + .stream() + .map(ComputationResources::map) + .collect(Collectors.toList()))); + return ret; + } + + static ApiCompParm map(DbCompParm parm) + { + ApiCompParm ret = new ApiCompParm(); + if (parm.getDataType() != null) + { + ret.setDataType(parm.getDataType().getDisplayName()); + } + ret.setInterval(parm.getInterval()); + if (parm.getSiteName() != null) + { + ret.setSiteName(parm.getSiteName().getDisplayName()); + } + if (parm.getSiteId() != null) + { + ret.setSiteId(parm.getSiteId().getValue()); + } + else + { + ret.setSiteId(DbKey.NullKey.getValue()); + } + ret.setUnitsAbbr(parm.getUnitsAbbr()); + ret.setAlgoParmType(parm.getAlgoParmType()); + ret.setAlgoRoleName(parm.getRoleName()); + ret.setDuration(parm.getDuration()); + ret.setInterval(parm.getInterval()); + ret.setDeltaT(parm.getDeltaT()); + if (parm.getDataTypeId() != null) + { + ret.setDataTypeId(parm.getDataTypeId().getValue()); + } + else + { + ret.setDataTypeId(DbKey.NullKey.getValue()); + } + ret.setDeltaTUnits(parm.getDeltaTUnits()); + ret.setVersion(parm.getVersion()); + ret.setModelId(parm.getModelId()); + ret.setTableSelector(parm.getTableSelector()); + ret.setParamType(parm.getParamType()); + return ret; + } + @POST @Path("computation") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_ADMIN, AuthorizationCheck.ODCS_API_USER}) public Response postComputation(ApiComputation comp) - throws WebAppException, DbException, SQLException + throws DbException + { + try (ComputationDAI dai = getLegacyTimeseriesDB().makeComputationDAO()) + { + DbComputation dbComp = map(comp); + dai.writeComputation(dbComp); + return Response.status(HttpServletResponse.SC_OK).entity(map(dbComp)).build(); + } + catch(DbIoException e) + { + throw new DbException("Unable to store computation", e); + } + } + + static DbComputation map(ApiComputation comp) + { + DbComputation ret; + if (comp.getComputationId() != null) + { + ret = new DbComputation(DbKey.createDbKey(comp.getComputationId()), comp.getName()); + } + else + { + ret = new DbComputation(DbKey.NullKey, comp.getName()); + } + if (comp.getAlgorithmId() != null) + { + ret.setAlgorithmId(DbKey.createDbKey(comp.getAlgorithmId())); + } + if (comp.getAppId() != null) + { + ret.setAppId(DbKey.createDbKey(comp.getAppId())); + } + ret.setComment(comp.getComment()); + ret.setEnabled(comp.isEnabled()); + ret.setValidEnd(comp.getEffectiveEndDate()); + ret.setValidStart(comp.getEffectiveStartDate()); + ret.setAlgorithmName(comp.getAlgorithmName()); + if (comp.getAlgorithmId() != null) + { + ret.setAlgorithm(new DbCompAlgorithm(DbKey.createDbKey(comp.getAlgorithmId()), + comp.getAlgorithmName(), null, comp.getComment())); + } + ret.setApplicationName(comp.getApplicationName()); + ret.setGroup(new TsGroup().copy(comp.getGroupName())); + ret.setLastModified(comp.getLastModified()); + if (comp.getGroupId() != null) + { + ret.setGroupId(DbKey.createDbKey(comp.getGroupId())); + } + else + { + ret.setGroupId(DbKey.NullKey); + } + for (String prop : comp.getProps().stringPropertyNames()) + { + ret.setProperty(prop, comp.getProps().getProperty(prop)); + } + for (ApiCompParm parm : comp.getParmList()) + { + ret.addParm(map(parm)); + } + return ret; + } + + static DbCompParm map(ApiCompParm parm) { - Logger.getLogger(ApiConstants.loggerName).fine("post comp received comp " + comp.getName() - + " with ID=" + comp.getComputationId()); - - try (DbInterface dbi = new DbInterface(); - ApiComputationDAO dao = new ApiComputationDAO(dbi)) + if (parm == null) + { + return null; + } + DbCompParm ret = new DbCompParm(parm.getAlgoRoleName(), + parm.getSiteId() != null ? DbKey.createDbKey(parm.getSiteId()) : DbKey.NullKey, + parm.getInterval(), parm.getTableSelector(), parm.getDeltaT()); + if (parm.getDataTypeId() != null) + { + DataType dt = new DataType(parm.getDataType(), parm.getDataTypeId().toString()); + ret.setDataType(dt); + } + ret.setInterval(parm.getInterval()); + if (parm.getSiteId() != null) { - return ApiHttpUtil.createResponse(dao.writeComputation(comp)); + Site site = new Site(); + site.setPublicName(parm.getSiteName()); + ret.setSite(site); + ret.setSiteId(DbKey.createDbKey(parm.getSiteId())); } + else + { + ret.setSiteId(DbKey.NullKey); + } + ret.setUnitsAbbr(parm.getUnitsAbbr()); + ret.setAlgoParmType(parm.getAlgoParmType()); + ret.setRoleName(parm.getAlgoRoleName()); + ret.setInterval(parm.getInterval()); + ret.setDeltaT(parm.getDeltaT()); + ret.setDeltaTUnits(parm.getDeltaTUnits()); + if (parm.getModelId() != null) + { + ret.setModelId(parm.getModelId()); + } + ret.setTableSelector(parm.getTableSelector()); + ret.setInterval(parm.getInterval()); + ret.setDeltaT(parm.getDeltaT()); + ret.setUnitsAbbr(parm.getUnitsAbbr()); + return ret; } @DELETE @@ -112,18 +388,23 @@ public Response postComputation(ApiComputation comp) @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) @RolesAllowed({AuthorizationCheck.ODCS_API_ADMIN, AuthorizationCheck.ODCS_API_USER}) - public Response deleteComputation(@QueryParam("computationid") Long computationId) throws DbException + public Response deleteComputation(@QueryParam("computationid") Long computationId) + throws DbException, WebAppException { - Logger.getLogger(ApiConstants.loggerName).fine( - "DELETE computation received computationId=" + computationId); - - // Use username and password to attempt to connect to the database - try (DbInterface dbi = new DbInterface(); - ApiComputationDAO dao = new ApiComputationDAO(dbi)) + if (computationId == null) { - dao.deleteComputation(computationId); - return ApiHttpUtil.createResponse("Computation with ID " + computationId + " deleted"); + throw new WebAppException(HttpServletResponse.SC_BAD_REQUEST, "Missing required computationid parameter."); + } + try (ComputationDAI dai = getLegacyTimeseriesDB().makeComputationDAO()) + { + dai.deleteComputation(DbKey.createDbKey(computationId)); + return Response.status(HttpServletResponse.SC_OK) + .entity("Computation with ID " + computationId + " deleted").build(); + } + catch(DbIoException | ConstraintException e) + { + throw new DbException(String.format("Unable to delete computation by ID: %s", computationId), e); } } } diff --git a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java index 5d3ccb088..eeebd1c28 100644 --- a/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java +++ b/opendcs-rest-api/src/main/java/org/opendcs/odcsapi/res/OpenDcsResource.java @@ -22,7 +22,10 @@ import javax.ws.rs.core.Context; import decodes.cwms.CwmsDatabaseProvider; +import decodes.db.Database; import decodes.db.DatabaseException; +import decodes.db.DatabaseIO; +import decodes.tsdb.TimeSeriesDb; import decodes.util.DecodesSettings; import opendcs.opentsdb.OpenTsdbProvider; import org.opendcs.database.DatabaseService; @@ -83,4 +86,16 @@ final OpenDcsDatabase createDb() } } } + + DatabaseIO getLegacyDatabase() + { + return createDb().getLegacyDatabase(Database.class).map(Database::getDbIo) + .orElseThrow(() -> new UnsupportedOperationException("Endpoint is unsupported by the OpenDCS REST API.")); + } + + TimeSeriesDb getLegacyTimeseriesDB() + { + return createDb().getLegacyDatabase(TimeSeriesDb.class) + .orElseThrow(() -> new UnsupportedOperationException("Endpoint is unsupported by the OpenDCS REST API.")); + } } diff --git a/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/ComputationResourcesTest.java b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/ComputationResourcesTest.java new file mode 100644 index 000000000..71fa27516 --- /dev/null +++ b/opendcs-rest-api/src/test/java/org/opendcs/odcsapi/res/ComputationResourcesTest.java @@ -0,0 +1,138 @@ +package org.opendcs.odcsapi.res; + +import java.sql.Date; +import java.time.Instant; +import java.util.ArrayList; +import java.util.stream.Collectors; + +import decodes.sql.DbKey; +import decodes.tsdb.DbCompAlgorithm; +import decodes.tsdb.DbComputation; +import decodes.tsdb.TsGroup; +import decodes.tsdb.compedit.ComputationInList; +import org.junit.jupiter.api.Test; +import org.opendcs.odcsapi.beans.ApiComputation; +import org.opendcs.odcsapi.beans.ApiComputationRef; + +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.ComputationResources.map; + +final class ComputationResourceTest +{ + @Test + void testApiComputeMap() + { + DbKey dbKey = DbKey.createDbKey(16704L); + String name = "Computation"; + DbComputation dbComp = new DbComputation(dbKey, name); + dbComp.setAlgorithmName("Computation Algorithm"); + dbComp.setComment("Computation to find the average of a set of values"); + dbComp.setAppId(DbKey.createDbKey(18596L)); + dbComp.setLastModified(Date.from(Instant.parse("2023-08-01T10:30:00Z"))); + dbComp.setAlgorithm(new DbCompAlgorithm(dbComp.getAlgorithmName())); + dbComp.setEnabled(true); + dbComp.setApplicationName("Average Application"); + dbComp.setValidStart(Date.from(Instant.parse("2023-07-01T00:30:00Z"))); + TsGroup group = new TsGroup(); + group.setGroupName("Computation group"); + group.setGroupId(DbKey.createDbKey(16753096L)); + dbComp.setGroup(group); + dbComp.setEnabled(true); + dbComp.setAlgorithmId(DbKey.createDbKey(197865L)); + dbComp.setValidEnd(Date.from(Instant.parse("2023-08-03T00:30:00Z"))); + + ApiComputation apiComp = map(dbComp); + + assertNotNull(apiComp); + assertEquals(dbComp.getId().getValue(), apiComp.getComputationId()); + assertEquals(dbComp.getAlgorithmName(), apiComp.getAlgorithmName()); + assertEquals(dbComp.getComment(), apiComp.getComment()); + assertEquals(dbComp.getAppId().getValue(), apiComp.getAppId()); + assertEquals(dbComp.getLastModified(), apiComp.getLastModified()); + assertEquals(dbComp.getAlgorithm().getName(), apiComp.getAlgorithmName()); + assertEquals(dbComp.getAlgorithmId().getValue(), apiComp.getAlgorithmId()); + assertEquals(dbComp.isEnabled(), apiComp.isEnabled()); + assertEquals(dbComp.getApplicationName(), apiComp.getApplicationName()); + assertEquals(dbComp.getValidStart(), apiComp.getEffectiveStartDate()); + assertEquals(dbComp.getValidEnd(), apiComp.getEffectiveEndDate()); + assertTrue(apiComp.isEnabled()); + assertEquals(dbComp.getGroup().getGroupName(), apiComp.getGroupName()); + assertEquals(dbComp.getGroupId().getValue(), apiComp.getGroupId()); + assertEquals(dbComp.getName(), apiComp.getName()); + assertEquals(dbComp.getProperties(), apiComp.getProps()); + assertEquals(dbComp.getParmList().stream().map(ComputationResources::map).collect(Collectors.toList()), + apiComp.getParmList()); + } + + @Test + void testDbComputeMap() + { + ApiComputation apiComp = new ApiComputation(); + apiComp.setComputationId(16704L); + apiComp.setName("Area Computation"); + apiComp.setAlgorithmName("Area Algorithm"); + apiComp.setComment("Computation to find the area of a given object"); + apiComp.setAppId(1L); + apiComp.setLastModified(Date.from(Instant.parse("2023-08-01T10:30:00Z"))); + apiComp.setEnabled(true); + apiComp.setApplicationName("Area Application"); + apiComp.setEffectiveStartDate(Date.from(Instant.parse("2023-07-01T00:30:00Z"))); + apiComp.setEffectiveEndDate(Date.from(Instant.parse("2023-08-03T00:30:00Z"))); + apiComp.setAlgorithmId(197865L); + apiComp.setGroupName("Computation Group"); + apiComp.setGroupId(16753096L); + DbComputation dbComp = map(apiComp); + assertNotNull(dbComp); + assertEquals(apiComp.getComputationId(), dbComp.getKey().getValue()); + assertEquals(apiComp.getName(), dbComp.getName()); + assertEquals(apiComp.getAlgorithmName(), dbComp.getAlgorithmName()); + assertEquals(apiComp.getComment(), dbComp.getComment()); + assertEquals(apiComp.getAppId(), dbComp.getAppId().getValue()); + assertEquals(apiComp.getLastModified(), dbComp.getLastModified()); + assertEquals(apiComp.getAlgorithmName(), dbComp.getAlgorithm().getName()); + assertEquals(apiComp.isEnabled(), dbComp.isEnabled()); + assertEquals(apiComp.getApplicationName(), dbComp.getApplicationName()); + assertEquals(apiComp.getEffectiveStartDate(), dbComp.getValidStart()); + assertEquals(apiComp.getEffectiveEndDate(), dbComp.getValidEnd()); + assertTrue(dbComp.isEnabled()); + assertEquals(apiComp.getGroupName(), dbComp.getGroup().getGroupName()); + assertEquals(apiComp.getGroupId(), dbComp.getGroupId().getValue()); + assertEquals(apiComp.getName(), dbComp.getName()); + assertEquals(apiComp.getProps(), dbComp.getProperties()); + assertEquals(apiComp.getParmList().stream().map(ComputationResources::map).collect(Collectors.toList()), + dbComp.getParmList()); + assertEquals(apiComp.getAlgorithmId(), dbComp.getAlgorithm().getId().getValue()); + } + + @Test + void testComputationRefMap() + { + ArrayList comps = new ArrayList<>(); + ComputationInList dbComp = new ComputationInList(DbKey.createDbKey(16704L), "Flow Computation", + DbKey.createDbKey(197865L), DbKey.createDbKey(51981L), + true, "Computation to find the flow rate of a body of water"); + dbComp.setAlgorithmName("Flow Algorithm"); + dbComp.setDescription("Computation to determine flow rate"); + dbComp.setProcessId(DbKey.createDbKey(1L)); + DbCompAlgorithm dbCompAlgorithm = new DbCompAlgorithm("Flow Algorithm"); + dbCompAlgorithm.setId(DbKey.createDbKey(197865L)); + dbComp.setEnabled(true); + comps.add(dbComp); + + ArrayList apiComps = map(comps); + + assertNotNull(apiComps); + assertEquals(1, apiComps.size()); + ApiComputationRef apiComp = apiComps.get(0); + assertNotNull(apiComp); + assertEquals(dbComp.getComputationId().getValue(), apiComp.getComputationId()); + assertEquals(dbComp.getComputationName(), apiComp.getName()); + assertEquals(dbComp.getAlgorithmName(), apiComp.getAlgorithmName()); + assertEquals(dbComp.getDescription(), apiComp.getDescription()); + assertEquals(dbComp.getProcessId().getValue(), apiComp.getProcessId()); + assertEquals(dbComp.getProcessName(), apiComp.getProcessName()); + assertEquals(dbComp.getAlgorithmId().getValue(), apiComp.getAlgorithmId()); + } +}