diff --git a/src/main/java/io/swagger/api/core/ListsApi.java b/src/main/java/io/swagger/api/core/ListsApi.java index b4c95e98..398c7cb5 100644 --- a/src/main/java/io/swagger/api/core/ListsApi.java +++ b/src/main/java/io/swagger/api/core/ListsApi.java @@ -5,13 +5,10 @@ */ package io.swagger.api.core; +import com.fasterxml.jackson.databind.JsonNode; import io.swagger.model.BrAPIResponse; import io.swagger.model.Model202AcceptedSearchResponse; -import io.swagger.model.core.ListNewRequest; -import io.swagger.model.core.ListResponse; -import io.swagger.model.core.ListSearchRequest; -import io.swagger.model.core.ListsListResponse; -import io.swagger.model.core.ListsSingleResponse; +import io.swagger.model.core.*; import io.swagger.annotations.*; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; @@ -166,4 +163,15 @@ ResponseEntity searchListsSearchResultsDbIdGet( @ApiParam(value = "pageSize") @Valid @RequestParam(value = "pageSize", required = false) Integer pageSize, @ApiParam(value = "HTTP HEADER - Token used for Authorization Bearer {token_string} ") @RequestHeader(value = "Authorization", required = false) String authorization) throws BrAPIServerException; + @ApiOperation(value = "Submit a search request for List Items", nickname = "searchListByItemRequest", notes = "Advanced searching for the list item resource. See Search Services for additional implementation details.", response = ListItemsListResponse.class, authorizations = { + @Authorization(value = "AuthorizationToken") }, tags = { "Lists", }) + @ApiResponses(value = { @ApiResponse(code = 200, message = "OK", response = ListItemsListResponse.class), + @ApiResponse(code = 400, message = "Bad Request", response = String.class), + @ApiResponse(code = 401, message = "Unauthorized", response = String.class), + @ApiResponse(code = 403, message = "Forbidden", response = String.class) }) + @RequestMapping(value = "/search/lists/{listDbId}/items", produces = { "application/json" }, consumes = { + "application/json" }, method = RequestMethod.POST) + ResponseEntity searchListByItemRequest(@ApiParam(value = "") @Valid @RequestBody JsonNode body, + @ApiParam(value = "Permanent unique identifier of list to perform search on", required = true) @PathVariable("listDbId") String listDbId, + @ApiParam(value = "HTTP HEADER - Token used for Authorization Bearer {token_string} ") @RequestHeader(value = "Authorization", required = false) String authorization) throws BrAPIServerException; } diff --git a/src/main/java/io/swagger/api/germ/GermplasmApi.java b/src/main/java/io/swagger/api/germ/GermplasmApi.java index 1990ba83..a7f9d959 100644 --- a/src/main/java/io/swagger/api/germ/GermplasmApi.java +++ b/src/main/java/io/swagger/api/germ/GermplasmApi.java @@ -143,6 +143,7 @@ ResponseEntity germplasmGet( @ApiParam(value = "progenyDbId") @Valid @RequestParam(value = "progenyDbId", required = false) String progenyDbId, @ApiParam(value = "commonCropName") @Valid @RequestParam(value = "commonCropName", required = false) String commonCropName, @ApiParam(value = "programDbId") @Valid @RequestParam(value = "programDbId", required = false) String programDbId, + @ApiParam(value = "programName") @Valid @RequestParam(value = "programName", required = false) String programName, @ApiParam(value = "externalReferenceID") @Valid @RequestParam(value = "externalReferenceID", required = false) String externalReferenceID, @ApiParam(value = "externalReferenceId") @Valid @RequestParam(value = "externalReferenceId", required = false) String externalReferenceId, @ApiParam(value = "externalReferenceSource") @Valid @RequestParam(value = "externalReferenceSource", required = false) String externalReferenceSource, diff --git a/src/main/java/io/swagger/model/FilterBy.java b/src/main/java/io/swagger/model/FilterBy.java new file mode 100644 index 00000000..acbc03e7 --- /dev/null +++ b/src/main/java/io/swagger/model/FilterBy.java @@ -0,0 +1,24 @@ +package io.swagger.model; + +public class FilterBy { + + private String filterOn; + private String value; + + public String getFilterOn() { + return filterOn; + } + + public void setFilterOn(String filterOn) { + this.filterOn = filterOn; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + +} diff --git a/src/main/java/io/swagger/model/SearchRequest.java b/src/main/java/io/swagger/model/SearchRequest.java index 8ad217c4..7999746f 100644 --- a/src/main/java/io/swagger/model/SearchRequest.java +++ b/src/main/java/io/swagger/model/SearchRequest.java @@ -2,9 +2,15 @@ import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.model.sort.SortBy; +import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; +import org.springframework.http.HttpStatus; import java.util.ArrayList; import java.util.List; +import java.util.Map; public abstract class SearchRequest { @JsonIgnore @@ -25,6 +31,20 @@ public abstract class SearchRequest { @JsonProperty("externalReferenceSources") protected List externalReferenceSources = null; + @JsonProperty("filterBy") + protected List filterBy = null; + + @JsonProperty("sortBy") + protected List sortBy = null; + + @JsonIgnore + protected Map sortFilterEntityColumnNamesByRequestName = null; + + @JsonIgnore + public List getExternalReferenceIds() { + return externalReferenceIds; + } + final public SearchRequest page(Integer page) { this.page = page; return this; @@ -119,4 +139,76 @@ public void addExternalReferenceItem(String externalReferenceId, String external } } + + public List getFilterBy() { + return filterBy; + } + + public void setFilterBy(List filterBy) throws BrAPIServerException { + + if (filterBy == null || filterBy.isEmpty()) { + return; + } + + Map allowedSortFilterNames = getEntityColInfoBySubmittedNameMap(); + + for (FilterBy filterByItem : filterBy) { + + if (filterByItem.getFilterOn() == null || filterByItem.getFilterOn().isEmpty()) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "filterOn attribute not provided in element of filterBy list."); + } + + if (filterByItem.getValue() == null || filterByItem.getValue().isEmpty()) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "value attribute not provided in element of filterBy list."); + } + + SortAndFilterEntityColumnInfo sortAndFilterEntityColumnInfo = allowedSortFilterNames.get(filterByItem.getFilterOn()); + + if (sortAndFilterEntityColumnInfo == null) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, + String.format("Supplied filterColumn [%s] not available in allowed names [%s]", filterByItem.getFilterOn(), allowedSortFilterNames.keySet()) + ); + } + + if (sortAndFilterEntityColumnInfo.getEntityType() == EntityType.BOOLEAN) { + // TODO: Add support for this when it becomes relevant for BI or when there is time. + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, String.format("Filtering not implemented for column name [%s] with associated data type [%s]", sortAndFilterEntityColumnInfo.getEntityColumnName(), EntityType.BOOLEAN)); + } + } + this.filterBy = filterBy; + } + + public List getSortByElements() { + return sortBy; + } + + public void setSortBy(List sortBy) throws BrAPIServerException { + + if (sortBy == null || sortBy.isEmpty()) { + return; + } + + Map allowedSortFilterNames = getEntityColInfoBySubmittedNameMap(); + + for (SortBy sortByItem : sortBy) { + if (sortByItem.getSortedOn() == null || sortByItem.getSortedOn().isEmpty()) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "sortedOn attribute not provided in element of sortBy list"); + } + + SortAndFilterEntityColumnInfo sortColumnEntityNameAndType = getEntityColInfoBySubmittedNameMap().get(sortByItem.getSortedOn()); + + if (sortColumnEntityNameAndType == null) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, + String.format("Supplied sortColumn [%s] not available in allowed names [%s]", sortByItem.getSortedOn(), allowedSortFilterNames.keySet()) + ); + } + } + + this.sortBy = sortBy; + } + + @JsonIgnore + public Map getEntityColInfoBySubmittedNameMap() throws BrAPIServerException { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, String.format("Sort/Filtering not implemented for %s", this.getClass().getSimpleName())); + } } diff --git a/src/main/java/io/swagger/model/core/GermplasmListSearchRequest.java b/src/main/java/io/swagger/model/core/GermplasmListSearchRequest.java new file mode 100644 index 00000000..5768d82b --- /dev/null +++ b/src/main/java/io/swagger/model/core/GermplasmListSearchRequest.java @@ -0,0 +1,33 @@ +package io.swagger.model.core; + +import io.swagger.model.germ.GermplasmSearchRequest; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; + +import java.util.Collections; +import java.util.Map; + +public class GermplasmListSearchRequest extends GermplasmSearchRequest { + + // The only real difference in this request is that there's an extra sort/filter field that GermplasmSearchRequest doesn't have. + // It is specific to lists. In general, other EntityListSearchRequests like this one should look the same, but have different base search requests. + private static final Map + LIST_ALLOWED_FIELDS; + + static { + Map fields = + copyAllowedSortAndFilterFields(); + + fields.put( + "listItemPosition", + new SortAndFilterEntityColumnInfo("*listItem.positionIndexedBy1", EntityType.NUMBER, false, true) + ); + + LIST_ALLOWED_FIELDS = Collections.unmodifiableMap(fields); + } + + @Override + public Map getEntityColInfoBySubmittedNameMap() { + return LIST_ALLOWED_FIELDS; + } +} diff --git a/src/main/java/io/swagger/model/core/ListItem.java b/src/main/java/io/swagger/model/core/ListItem.java new file mode 100644 index 00000000..a3f70dd2 --- /dev/null +++ b/src/main/java/io/swagger/model/core/ListItem.java @@ -0,0 +1,95 @@ +package io.swagger.model.core; + +import java.util.Objects; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import org.springframework.validation.annotation.Validated; + +/** + * ListItem + */ +@Validated +@javax.annotation.processing.Generated(value = "io.swagger.codegen.v3.generators.java.SpringCodegen", date = "2020-03-20T16:31:52.030Z[GMT]") +public class ListItem { + @JsonProperty("listItemDbId") + private String listItemDbId = null; + + @JsonProperty("position") + private Integer position = null; + + // This represents the actual value stored in the list_item table + @JsonProperty("item") + private String item = null; + + /** + * The unique identifier for a List + * @return listDbId + **/ + @ApiModelProperty(example = "6f621cfa", required = true, value = "The unique identifier for a List") + + + public String getListItemDbId() { + return listItemDbId; + } + + public void setListItemDbId(String listItemDbId) { + this.listItemDbId = listItemDbId; + } + + public Integer getPosition() { + return position; + } + + public void setPosition(Integer position) { + this.position = position; + } + + public String getItem() { + return item; + } + + public void setItem(String item) { + this.item = item; + } + + @Override + public boolean equals(java.lang.Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ListItem ListItem = (ListItem) o; + return Objects.equals(this.listItemDbId, ListItem.listItemDbId) && + super.equals(o); + } + + @Override + public int hashCode() { + return Objects.hash(listItemDbId, super.hashCode()); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ListItem {\n"); + sb.append(" ").append(toIndentedString(super.toString())).append("\n"); + sb.append(" listDbId: ").append(toIndentedString(listItemDbId)).append("\n"); + sb.append("}"); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces + * (except the first line). + */ + private String toIndentedString(java.lang.Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} + + diff --git a/src/main/java/io/swagger/model/core/ListItemWithFullItem.java b/src/main/java/io/swagger/model/core/ListItemWithFullItem.java new file mode 100644 index 00000000..abe035c0 --- /dev/null +++ b/src/main/java/io/swagger/model/core/ListItemWithFullItem.java @@ -0,0 +1,83 @@ +package io.swagger.model.core; + +import java.util.Objects; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import org.springframework.validation.annotation.Validated; + +/** + * ListItemWithFullItem + */ +@Validated +@javax.annotation.processing.Generated(value = "io.swagger.codegen.v3.generators.java.SpringCodegen", date = "2020-03-20T16:31:52.030Z[GMT]") +public class ListItemWithFullItem { + @JsonProperty("listItem") + private ListItem listItem = null; + + // The full actual BrAPI model object of the list item is supplied/written into here + @JsonProperty("item") + private T item = null; + + /** + * The unique identifier for a List + * @return listItem + **/ + @ApiModelProperty(example = "6f621cfa", required = true, value = "The unique identifier for a List") + + + public ListItem getListItem() { + return listItem; + } + + public void setListItem(ListItem listItem) { + this.listItem = listItem; + } + + public T getItem() { + return item; + } + + public void setItem(T item) { + this.item = item; + } + + @Override + public boolean equals(java.lang.Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ListItemWithFullItem listItemWithFullItem = (ListItemWithFullItem) o; + return Objects.equals(this.listItem, listItemWithFullItem.listItem) && + super.equals(o); + } + + @Override + public int hashCode() { + return Objects.hash(listItem, super.hashCode()); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ListItemWithFullItem {\n"); + sb.append(" ").append(toIndentedString(super.toString())).append("\n"); + sb.append(" listItem: ").append(toIndentedString(listItem)).append("\n"); + sb.append("}"); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces + * (except the first line). + */ + private String toIndentedString(java.lang.Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} + diff --git a/src/main/java/io/swagger/model/core/ListItemsListResponse.java b/src/main/java/io/swagger/model/core/ListItemsListResponse.java new file mode 100644 index 00000000..7b70e536 --- /dev/null +++ b/src/main/java/io/swagger/model/core/ListItemsListResponse.java @@ -0,0 +1,134 @@ +package io.swagger.model.core; + +import java.util.Objects; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import io.swagger.model.BrAPIResponse; +import io.swagger.model.Context; +import io.swagger.model.Metadata; + +import org.springframework.validation.annotation.Validated; +import jakarta.validation.Valid; + +/** + * ListItemsListResponse + */ +@Validated +@javax.annotation.processing.Generated(value = "io.swagger.codegen.v3.generators.java.SpringCodegen", date = "2020-03-20T16:31:52.030Z[GMT]") +public class ListItemsListResponse implements BrAPIResponse> { + @JsonProperty("@context") + private Context _atContext = null; + + @JsonProperty("metadata") + private Metadata metadata = null; + + // This piece of data is used by the brapi client to determine and populate the exact data model return type of ListItemWithFullItem.item + @JsonProperty("resultListType") + private ListTypes resultListType = null; + + @JsonProperty("result") + private ListItemsListResponseResult result = null; + + public ListItemsListResponse() { + this._atContext = new Context(); + this._atContext.add("context"); + } + + + public void set_atContext(Context _atContext) { + this._atContext = _atContext; + } + public ListItemsListResponse metadata(Metadata metadata) { + this.metadata = metadata; + return this; + } + + /** + * Get metadata + * + * @return metadata + **/ + @ApiModelProperty(required = true, value = "") + + + @Valid + public Metadata getMetadata() { + return metadata; + } + + public void setMetadata(Metadata metadata) { + this.metadata = metadata; + } + + public ListItemsListResponse result(ListItemsListResponseResult result) { + this.result = result; + return this; + } + + /** + * Get result + * + * @return result + **/ + @ApiModelProperty(required = true, value = "") + + + @Valid + public ListItemsListResponseResult getResult() { + return result; + } + + public void setResult(ListItemsListResponseResult result) { + this.result = result; + } + + public ListTypes getResultListType() { + return resultListType; + } + + public void setResultListType(ListTypes resultListType) { + this.resultListType = resultListType; + } + + @Override + public boolean equals(java.lang.Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ListItemsListResponse listItemsListResponse = (ListItemsListResponse) o; + return Objects.equals(this._atContext, listItemsListResponse._atContext) + && Objects.equals(this.metadata, listItemsListResponse.metadata) + && Objects.equals(this.result, listItemsListResponse.result); + } + + @Override + public int hashCode() { + return Objects.hash(_atContext, metadata, result); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ListItemsListResponse {\n"); + + sb.append(" _atContext: ").append(toIndentedString(_atContext)).append("\n"); + sb.append(" metadata: ").append(toIndentedString(metadata)).append("\n"); + sb.append(" result: ").append(toIndentedString(result)).append("\n"); + sb.append("}"); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces + * (except the first line). + */ + private String toIndentedString(java.lang.Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/io/swagger/model/core/ListItemsListResponseResult.java b/src/main/java/io/swagger/model/core/ListItemsListResponseResult.java new file mode 100644 index 00000000..892a2dba --- /dev/null +++ b/src/main/java/io/swagger/model/core/ListItemsListResponseResult.java @@ -0,0 +1,87 @@ +package io.swagger.model.core; + +import java.util.Objects; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import io.swagger.model.BrAPIResponseResult; + +import java.util.ArrayList; +import java.util.List; +import org.springframework.validation.annotation.Validated; +import jakarta.validation.Valid; + +/** + * ListItemsListResponseResult + */ +@Validated +@javax.annotation.processing.Generated(value = "io.swagger.codegen.v3.generators.java.SpringCodegen", date = "2020-03-20T16:31:52.030Z[GMT]") +public class ListItemsListResponseResult implements BrAPIResponseResult> { + @JsonProperty("data") + @Valid + private List> data = new ArrayList>(); + + public ListItemsListResponseResult data(List> data) { + this.data = data; + return this; + } + + public ListItemsListResponseResult addDataItem(ListItemWithFullItem dataItem) { + this.data.add(dataItem); + return this; + } + + /** + * Get data + * @return data + **/ + @ApiModelProperty(required = true, value = "") + + @Valid + public List> getData() { + return data; + } + + public void setData(List> data) { + this.data = data; + } + + + @Override + public boolean equals(java.lang.Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ListItemsListResponseResult listItemsListResponseResult = (ListItemsListResponseResult) o; + return Objects.equals(this.data, listItemsListResponseResult.data); + } + + @Override + public int hashCode() { + return Objects.hash(data); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class ListItemsListResponseResult {\n"); + + sb.append(" data: ").append(toIndentedString(data)).append("\n"); + sb.append("}"); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces + * (except the first line). + */ + private String toIndentedString(java.lang.Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} + diff --git a/src/main/java/io/swagger/model/core/SortBy.java b/src/main/java/io/swagger/model/core/SortBy.java deleted file mode 100644 index 8a132a3e..00000000 --- a/src/main/java/io/swagger/model/core/SortBy.java +++ /dev/null @@ -1,56 +0,0 @@ -package io.swagger.model.core; - -import com.fasterxml.jackson.annotation.JsonCreator; -import com.fasterxml.jackson.annotation.JsonValue; - -public enum SortBy { - - STUDYDBID("studyDbId"), - - STARTDATE("startDate"), - - ENDDATE("endDate"), - - TRIALDBID("trialDbId"), - - TRIALNAME("trialName"), - - PROGRAMDBID("programDbId"), - - LOCATIONDBID("locationDbId"), - - SEASONDBID("seasonDbId"), - - STUDYTYPE("studyType"), - - STUDYNAME("studyName"), - - STUDYLOCATION("studyLocation"), - - PROGRAMNAME("programName"), - - GERMPLASMDBID("germplasmDbId"), - - OBSERVATIONVARIABLEDBID("observationVariableDbId"); -private String value; - - SortBy(String value) { - this.value = value; - } - - @Override - @JsonValue - public String toString() { - return String.valueOf(value); - } - - @JsonCreator - public static SortBy fromValue(String text) { - for (SortBy b : SortBy.values()) { - if (String.valueOf(b.value).equals(text)) { - return b; - } - } - return null; - } -} diff --git a/src/main/java/io/swagger/model/core/StudySearchRequest.java b/src/main/java/io/swagger/model/core/StudySearchRequest.java index 0b26436b..a9c3c9cd 100644 --- a/src/main/java/io/swagger/model/core/StudySearchRequest.java +++ b/src/main/java/io/swagger/model/core/StudySearchRequest.java @@ -1,14 +1,41 @@ package io.swagger.model.core; +import java.util.Map; import java.util.Objects; import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.model.SearchRequest; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; + import java.util.ArrayList; import java.util.List; public class StudySearchRequest extends SearchRequest { + + // Key - allowed sort or field filter name for this entity + // Value = entity field name and type that represents the submitted field. Used later on in query building. + private static final Map ALLOWED_SORT_AND_FILTER_FIELDS = + Map.ofEntries( + Map.entry("commonCropName", new SortAndFilterEntityColumnInfo("crop.cropName", EntityType.TEXT)), + Map.entry("externalReferenceId", new SortAndFilterEntityColumnInfo("*externalReferences.externalReferenceId", EntityType.TEXT, true, false)), + Map.entry("externalReferenceSource", new SortAndFilterEntityColumnInfo("*externalReferences.externalReferenceSource", EntityType.TEXT, true, false)), + Map.entry("germplasmDbId", new SortAndFilterEntityColumnInfo("*obsunit.germplasm.id", EntityType.UUID, true, false)), + Map.entry("locationDbId", new SortAndFilterEntityColumnInfo("location.id", EntityType.UUID)), + Map.entry("observationVariableDbId", new SortAndFilterEntityColumnInfo("*observation.observationVariable.id", EntityType.UUID, true, false)), + Map.entry("programDbId", new SortAndFilterEntityColumnInfo("trial.program.id", EntityType.UUID)), + Map.entry("programName", new SortAndFilterEntityColumnInfo("trial.program.name", EntityType.TEXT)), + Map.entry("seasonDbId", new SortAndFilterEntityColumnInfo("*season.id", EntityType.UUID, true, false)), + Map.entry("studyCode", new SortAndFilterEntityColumnInfo("studyCode", EntityType.TEXT)), + Map.entry("studyDbId", new SortAndFilterEntityColumnInfo("id", EntityType.UUID)), + Map.entry("studyLocation", new SortAndFilterEntityColumnInfo("location.id", EntityType.UUID)), + Map.entry("studyPUI", new SortAndFilterEntityColumnInfo("studyPUI", EntityType.TEXT)), + Map.entry("trialDbId", new SortAndFilterEntityColumnInfo("trial.id", EntityType.UUID)), + Map.entry("studyType", new SortAndFilterEntityColumnInfo("studyType", EntityType.TEXT)), + Map.entry("studyName", new SortAndFilterEntityColumnInfo("studyName", EntityType.TEXT)) + ); + @JsonProperty("commonCropNames") private List commonCropNames = null; @@ -54,12 +81,6 @@ public class StudySearchRequest extends SearchRequest { @JsonProperty("seasonDbIds") private List seasonDbIds = null; - @JsonProperty("sortBy") - private SortBy sortBy = null; - - @JsonProperty("sortOrder") - private SortOrder sortOrder = null; - @JsonProperty("studyCodes") private List studyCodes = null; @@ -376,32 +397,6 @@ public void setSeasonDbIds(List seasonDbIds) { this.seasonDbIds = seasonDbIds; } - public StudySearchRequest sortBy(SortBy sortBy) { - this.sortBy = sortBy; - return this; - } - - public SortBy getSortBy() { - return sortBy; - } - - public void setSortBy(SortBy sortBy) { - this.sortBy = sortBy; - } - - public StudySearchRequest sortOrder(SortOrder sortOrder) { - this.sortOrder = sortOrder; - return this; - } - - public SortOrder getSortOrder() { - return sortOrder; - } - - public void setSortOrder(SortOrder sortOrder) { - this.sortOrder = sortOrder; - } - public StudySearchRequest studyCodes(List studyCodes) { this.studyCodes = studyCodes; return this; @@ -492,7 +487,6 @@ public boolean equals(java.lang.Object o) { && Objects.equals(this.active, studySearchRequest.active) && Objects.equals(this.seasonDbIds, studySearchRequest.seasonDbIds) && Objects.equals(this.sortBy, studySearchRequest.sortBy) - && Objects.equals(this.sortOrder, studySearchRequest.sortOrder) && Objects.equals(this.studyCodes, studySearchRequest.studyCodes) && Objects.equals(this.studyPUIs, studySearchRequest.studyPUIs) && Objects.equals(this.studyTypes, studySearchRequest.studyTypes) && super.equals(o); @@ -503,7 +497,7 @@ public int hashCode() { return Objects.hash(commonCropNames, programDbIds, programNames, trialDbIds, trialNames, studyDbIds, studyNames, locationDbIds, locationNames, germplasmDbIds, germplasmNames, observationVariableDbIds, observationVariableNames, externalReferenceIds, externalReferenceSources, active, seasonDbIds, sortBy, - sortOrder, studyCodes, studyPUIs, studyTypes, super.hashCode()); + studyCodes, studyPUIs, studyTypes, super.hashCode()); } @Override @@ -529,7 +523,6 @@ public String toString() { sb.append(" active: ").append(toIndentedString(active)).append("\n"); sb.append(" seasonDbIds: ").append(toIndentedString(seasonDbIds)).append("\n"); sb.append(" sortBy: ").append(toIndentedString(sortBy)).append("\n"); - sb.append(" sortOrder: ").append(toIndentedString(sortOrder)).append("\n"); sb.append(" studyCodes: ").append(toIndentedString(studyCodes)).append("\n"); sb.append(" studyPUIs: ").append(toIndentedString(studyPUIs)).append("\n"); sb.append(" studyTypes: ").append(toIndentedString(studyTypes)).append("\n"); @@ -583,8 +576,6 @@ public Integer getTotalParameterCount() { count += this.seasonDbIds.size(); if (this.sortBy != null) count += 1; - if (this.sortOrder != null) - count += 1; if (this.studyCodes != null) count += this.studyCodes.size(); if (this.studyPUIs != null) @@ -593,4 +584,9 @@ public Integer getTotalParameterCount() { count += this.studyTypes.size(); return count; } + + @Override + public Map getEntityColInfoBySubmittedNameMap() { + return ALLOWED_SORT_AND_FILTER_FIELDS; + } } diff --git a/src/main/java/io/swagger/model/core/TrialSearchRequest.java b/src/main/java/io/swagger/model/core/TrialSearchRequest.java index 830dde51..f703010e 100644 --- a/src/main/java/io/swagger/model/core/TrialSearchRequest.java +++ b/src/main/java/io/swagger/model/core/TrialSearchRequest.java @@ -1,13 +1,32 @@ package io.swagger.model.core; -import java.util.Objects; +import java.util.*; + import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.model.SearchRequest; -import java.util.ArrayList; -import java.util.List; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; + import java.time.LocalDate; public class TrialSearchRequest extends SearchRequest { + + // Key - allowed sort or field filter name for this entity + // Value = entity field name and type that represents the submitted field. Used later on in query building. + private static final Map ALLOWED_SORT_AND_FILTER_FIELDS = + Map.of( + "trialName", new SortAndFilterEntityColumnInfo("trialName", EntityType.TEXT), + "createdDate", new SortAndFilterEntityColumnInfo("createdDate", EntityType.TEXT), + "createdBy", new SortAndFilterEntityColumnInfo("createdBy", EntityType.TEXT), + "trialDbId", new SortAndFilterEntityColumnInfo("id", EntityType.UUID), + "programDbId",new SortAndFilterEntityColumnInfo("program.id", EntityType.UUID), + "startDate", new SortAndFilterEntityColumnInfo("startDate", EntityType.TEXT), + "endDate", new SortAndFilterEntityColumnInfo("endDate", EntityType.TEXT), + "active", new SortAndFilterEntityColumnInfo("active", EntityType.BOOLEAN), + "programName", new SortAndFilterEntityColumnInfo("program.name", EntityType.TEXT), + "locationDbId", new SortAndFilterEntityColumnInfo("*studies.location.id", EntityType.UUID, true, false) + ); + @JsonProperty("commonCropNames") private List commonCropNames = null; @@ -50,28 +69,6 @@ public class TrialSearchRequest extends SearchRequest { @JsonProperty("trialPUIs") private List trialPUIs = null; - @JsonProperty("sortBy") - private SortBy sortBy = null; - - @JsonProperty("sortOrder") - private SortOrder sortOrder = null; - - public SortBy getSortBy() { - return sortBy; - } - - public void setSortBy(SortBy sortBy) { - this.sortBy = sortBy; - } - - public SortOrder getSortOrder() { - return sortOrder; - } - - public void setSortOrder(SortOrder sortOrder) { - this.sortOrder = sortOrder; - } - public TrialSearchRequest commonCropNames(List commonCropNames) { this.commonCropNames = commonCropNames; return this; @@ -445,4 +442,9 @@ public Integer getTotalParameterCount() { count += this.trialPUIs.size(); return count; } + + @Override + public Map getEntityColInfoBySubmittedNameMap() { + return ALLOWED_SORT_AND_FILTER_FIELDS; + } } diff --git a/src/main/java/io/swagger/model/germ/GermplasmNewRequest.java b/src/main/java/io/swagger/model/germ/GermplasmNewRequest.java index 253783e7..7317f374 100644 --- a/src/main/java/io/swagger/model/germ/GermplasmNewRequest.java +++ b/src/main/java/io/swagger/model/germ/GermplasmNewRequest.java @@ -97,6 +97,12 @@ public class GermplasmNewRequest extends BrAPIDataModel { @JsonProperty("taxonIds") private List taxonIds = null; + @JsonProperty("programDbId") + private String programDbId = null; + + @JsonProperty("programName") + private String programName = null; + public String getBreedingMethodName() { return breedingMethodName; } @@ -510,6 +516,22 @@ public void setTaxonIds(List taxonIds) { this.taxonIds = taxonIds; } + public String getProgramDbId() { + return programDbId; + } + + public void setProgramDbId(String programDbId) { + this.programDbId = programDbId; + } + + public String getProgramName() { + return programName; + } + + public void setProgramName(String programName) { + this.programName = programName; + } + @Override public boolean equals(java.lang.Object o) { if (this == o) { @@ -550,7 +572,9 @@ public boolean equals(java.lang.Object o) { && Objects.equals(this.subtaxa, germplasmNewRequest.subtaxa) && Objects.equals(this.subtaxaAuthority, germplasmNewRequest.subtaxaAuthority) && Objects.equals(this.synonyms, germplasmNewRequest.synonyms) - && Objects.equals(this.taxonIds, germplasmNewRequest.taxonIds); + && Objects.equals(this.taxonIds, germplasmNewRequest.taxonIds) + && Objects.equals(this.programDbId, germplasmNewRequest.programDbId) + && Objects.equals(this.programName, germplasmNewRequest.programName); } @Override @@ -560,7 +584,7 @@ public int hashCode() { countryOfOriginCode, defaultDisplayName, documentationURL, donors, externalReferences, genus, germplasmName, germplasmOrigin, germplasmPUI, germplasmPreprocessing, instituteCode, instituteName, pedigree, seedSource, seedSourceDescription, species, speciesAuthority, storageTypes, subtaxa, - subtaxaAuthority, synonyms, taxonIds); + subtaxaAuthority, synonyms, taxonIds, programDbId, programName); } @Override @@ -600,6 +624,8 @@ public String toString() { sb.append(" subtaxaAuthority: ").append(toIndentedString(subtaxaAuthority)).append("\n"); sb.append(" synonyms: ").append(toIndentedString(synonyms)).append("\n"); sb.append(" taxonIds: ").append(toIndentedString(taxonIds)).append("\n"); + sb.append(" programDbId: ").append(toIndentedString(programDbId)).append("\n"); + sb.append(" programName: ").append(toIndentedString(programName)).append("\n"); sb.append("}"); return sb.toString(); } diff --git a/src/main/java/io/swagger/model/germ/GermplasmSearchRequest.java b/src/main/java/io/swagger/model/germ/GermplasmSearchRequest.java index 36c58878..f25a5052 100644 --- a/src/main/java/io/swagger/model/germ/GermplasmSearchRequest.java +++ b/src/main/java/io/swagger/model/germ/GermplasmSearchRequest.java @@ -3,12 +3,35 @@ import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.model.SearchRequest; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; -import java.util.ArrayList; -import java.util.List; -import java.util.Objects; +import java.util.*; public class GermplasmSearchRequest extends SearchRequest { + + // Key - allowed sort or field filter name for this entity + // Value = entity field name and type that represents the submitted field. Used later on in query building. + private static final Map ALLOWED_SORT_AND_FILTER_FIELDS = + Map.ofEntries( + // accessionNumber = GID for DeltaBreed + Map.entry("accessionNumber", new SortAndFilterEntityColumnInfo("accessionNumber", EntityType.NUMBER)), + Map.entry("defaultDisplayName", new SortAndFilterEntityColumnInfo("defaultDisplayName", EntityType.TEXT)), + Map.entry("breedingMethod", new SortAndFilterEntityColumnInfo("methodName", EntityType.TEXT)), + Map.entry("seedSource", new SortAndFilterEntityColumnInfo("seedSource", EntityType.TEXT)), + Map.entry("pedigree",new SortAndFilterEntityColumnInfo("pedigree.pedigreeString", EntityType.TEXT)), + Map.entry("femaleParentGID", new SortAndFilterEntityColumnInfo("femaleParentGid", EntityType.TEXT)), + Map.entry("maleParentGID", new SortAndFilterEntityColumnInfo("maleParentGid", EntityType.TEXT)), + Map.entry("createdDate", new SortAndFilterEntityColumnInfo("createdDate", EntityType.DATE)), + Map.entry("createdBy", new SortAndFilterEntityColumnInfo("createdBy", EntityType.TEXT)), + Map.entry("importEntryNumber", new SortAndFilterEntityColumnInfo("importEntryNumber", EntityType.NUMBER, false, true)), + Map.entry("synonyms", new SortAndFilterEntityColumnInfo("*synonyms.synonym", EntityType.TEXT, true, false)) + ); + + protected static Map copyAllowedSortAndFilterFields() { + return new HashMap<>(ALLOWED_SORT_AND_FILTER_FIELDS); + } + @JsonProperty("accessionNumbers") private List accessionNumbers = null; @@ -574,6 +597,8 @@ private String toIndentedString(java.lang.Object o) { @Override @JsonIgnore + // TODO: NOTE - External Reference IDs, exref sources, germplasmNames and germplasmDbIds have been removed from the parameter count to speed up lookups and prevent async search requests. + // TODO: We would need to reconsider this if we decide to use parameter count as the way to trigger async requests when complete [BI-3021] public Integer getTotalParameterCount() { Integer count = 0; if (this.accessionNumbers != null) @@ -584,18 +609,10 @@ public Integer getTotalParameterCount() { count += this.collections.size(); if (this.commonCropNames != null) count += this.commonCropNames.size(); - if (this.externalReferenceIds != null) - count += this.externalReferenceIds.size(); - if (this.externalReferenceSources != null) - count += this.externalReferenceSources.size(); if (this.familyCodes != null) count += this.familyCodes.size(); if (this.genus != null) count += this.genus.size(); - if (this.germplasmDbIds != null) - count += this.germplasmDbIds.size(); - if (this.germplasmNames != null) - count += this.germplasmNames.size(); if (this.germplasmPUIs != null) count += this.germplasmPUIs.size(); if (this.instituteCodes != null) @@ -623,4 +640,9 @@ public Integer getTotalParameterCount() { return count; } + + @Override + public Map getEntityColInfoBySubmittedNameMap() { + return ALLOWED_SORT_AND_FILTER_FIELDS; + } } diff --git a/src/main/java/io/swagger/model/sort/SortBy.java b/src/main/java/io/swagger/model/sort/SortBy.java new file mode 100644 index 00000000..bb286fa6 --- /dev/null +++ b/src/main/java/io/swagger/model/sort/SortBy.java @@ -0,0 +1,30 @@ +package io.swagger.model.sort; + +public class SortBy { + private String sortedOn; + private SortOrder sortOrder = SortOrder.ASC; + + public SortBy(String sortedOn, + SortOrder sortOrder) { + this.sortedOn = sortedOn; + this.sortOrder = sortOrder; + } + + public SortBy() {} + + public String getSortedOn() { + return sortedOn; + } + + public void setSortedOn(String sortedOn) { + this.sortedOn = sortedOn; + } + + public SortOrder getSortOrder() { + return sortOrder; + } + + public void setSortOrder(SortOrder sortOrder) { + this.sortOrder = sortOrder; + } +} diff --git a/src/main/java/io/swagger/model/core/SortOrder.java b/src/main/java/io/swagger/model/sort/SortOrder.java similarity index 92% rename from src/main/java/io/swagger/model/core/SortOrder.java rename to src/main/java/io/swagger/model/sort/SortOrder.java index 0e5b36bd..b8a85ebf 100644 --- a/src/main/java/io/swagger/model/core/SortOrder.java +++ b/src/main/java/io/swagger/model/sort/SortOrder.java @@ -1,4 +1,4 @@ -package io.swagger.model.core; +package io.swagger.model.sort; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; @@ -26,6 +26,6 @@ public static SortOrder fromValue(String text) { return b; } } - return null; + return ASC; } } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/BrapiExceptionHandler.java b/src/main/java/org/brapi/test/BrAPITestServer/BrapiExceptionHandler.java index 7ee15a60..fa6508f0 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/BrapiExceptionHandler.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/BrapiExceptionHandler.java @@ -1,13 +1,12 @@ package org.brapi.test.BrAPITestServer; import java.util.ArrayList; +import java.util.Map; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; +import org.springframework.http.*; import org.springframework.http.converter.HttpMessageNotReadableException; import org.springframework.lang.Nullable; import org.springframework.web.bind.MissingServletRequestParameterException; @@ -70,4 +69,36 @@ private ResponseEntity buildErrorResponse(HttpStatus code, String messag return new ResponseEntity(apiError, code); } + + // This override handles JSON parsing failures detected by Jackson. + // It allows for capture of BrAPI generated BAD Request exceptions that are occur during serialization, + // like those involved in filtering and sorting in search requests. + @Override + protected ResponseEntity handleHttpMessageNotReadable( + HttpMessageNotReadableException ex, + HttpHeaders headers, + HttpStatusCode status, + WebRequest request + ) { + Throwable root = ex.getMostSpecificCause(); + + if (root instanceof BrAPIServerException brapiServerException) { + + ProblemDetail detail = + ProblemDetail.forStatus(HttpStatus.BAD_REQUEST); + + detail.setTitle("Bad Request"); + detail.setDetail(brapiServerException.getResponseMessage()); + + return ResponseEntity.badRequest().body(detail); + } + + // Delegate back to Spring default behavior + return super.handleHttpMessageNotReadable( + ex, + headers, + status, + request + ); + } } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/controller/core/BrAPIController.java b/src/main/java/org/brapi/test/BrAPITestServer/controller/core/BrAPIController.java index 05cd18bf..90f13064 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/controller/core/BrAPIController.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/controller/core/BrAPIController.java @@ -5,6 +5,7 @@ import java.util.Set; import java.util.stream.Collectors; +import com.fasterxml.jackson.databind.JsonNode; import jakarta.servlet.http.HttpServletRequest; import io.swagger.model.core.BatchDeletesListResponse; @@ -49,6 +50,26 @@ protected Metadata generateMetaDataTemplate(String pageToken, Integer pageSize) return metaData; } + // Used when endpoints require generic, untyped search bodies. (See ListsApiController.searchListByItemRequest) + protected Metadata generateMetaDataTemplate(JsonNode node) throws BrAPIServerException { + + Integer page = null; + Integer pageSize = null; + + JsonNode pageAsNode = node.get("page"); + JsonNode pageSizeAsNode = node.get("pageSize"); + + if (pageAsNode != null && pageAsNode.canConvertToInt()) { + page = pageAsNode.asInt(); + } + + if (pageSizeAsNode != null && pageSizeAsNode.canConvertToInt()) { + pageSize = pageSizeAsNode.asInt(); + } + + return generateMetaDataTemplate(page, pageSize); + } + protected Metadata generateMetaDataTemplate(Integer page, Integer pageSize) throws BrAPIServerException { PagingUtility.validatePaging(page, pageSize); diff --git a/src/main/java/org/brapi/test/BrAPITestServer/controller/core/ListsApiController.java b/src/main/java/org/brapi/test/BrAPITestServer/controller/core/ListsApiController.java index ce653cdf..43e831bd 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/controller/core/ListsApiController.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/controller/core/ListsApiController.java @@ -1,5 +1,6 @@ package org.brapi.test.BrAPITestServer.controller.core; +import com.fasterxml.jackson.databind.JsonNode; import io.swagger.model.BrAPIResponse; import io.swagger.model.Metadata; import io.swagger.model.core.*; @@ -12,6 +13,7 @@ import org.brapi.test.BrAPITestServer.model.entity.SearchRequestEntity; import org.brapi.test.BrAPITestServer.model.entity.SearchRequestEntity.SearchRequestTypes; import org.brapi.test.BrAPITestServer.service.SearchService; +import org.brapi.test.BrAPITestServer.service.core.ListItemService; import org.brapi.test.BrAPITestServer.service.core.ListService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -39,12 +41,14 @@ public class ListsApiController extends BrAPIController implements ListsApi { private final HttpServletRequest request; private final ListService listService; private final SearchService searchService; + private final ListItemService listItemService; @Autowired - public ListsApiController(ListService listService, SearchService searchService, HttpServletRequest request) { + public ListsApiController(ListService listService, SearchService searchService, HttpServletRequest request, ListItemService listItemService) { this.listService = listService; this.searchService = searchService; this.request = request; + this.listItemService = listItemService; } @CrossOrigin @@ -205,4 +209,26 @@ public ResponseEntity searchListsSearchResultsDbIdGet( } } + @CrossOrigin + @Override + public ResponseEntity searchListByItemRequest( + @Valid @RequestBody JsonNode body, + @PathVariable("listDbId") String listDbId, + @RequestHeader(value = "Authorization", required = false) String authorization) throws BrAPIServerException { + + log.debug("Request: " + request.getRequestURI()); + validateSecurityContext(request, "ROLE_ANONYMOUS", "ROLE_USER"); + validateAcceptHeader(request); + Metadata metadata = generateMetaDataTemplate(body); + + ListDetails list = listService.getList(listDbId); + List> data = listItemService.search(list, body, metadata); + + // Setting the resultListType here allows the BrAPI client to know how to initialize the parameterized ListItemWithFullItem.item class + ListItemsListResponse listItemsListResponse = new ListItemsListResponse(); + listItemsListResponse.setResultListType(list.getListType()); + + return responseOK(listItemsListResponse, new ListItemsListResponseResult(), data, metadata); + } + } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/controller/germ/GermplasmApiController.java b/src/main/java/org/brapi/test/BrAPITestServer/controller/germ/GermplasmApiController.java index 52e58a1d..dd462c4b 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/controller/germ/GermplasmApiController.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/controller/germ/GermplasmApiController.java @@ -156,6 +156,7 @@ public ResponseEntity germplasmGet( @RequestParam(value = "progenyDbId", required = false) String progenyDbId, @RequestParam(value = "commonCropName", required = false) String commonCropName, @RequestParam(value = "programDbId", required = false) String programDbId, + @RequestParam(value = "programName", required = false) String programName, @RequestParam(value = "externalReferenceID", required = false) String externalReferenceID, @RequestParam(value = "externalReferenceId", required = false) String externalReferenceId, @RequestParam(value = "externalReferenceSource", required = false) String externalReferenceSource, @@ -170,7 +171,7 @@ public ResponseEntity germplasmGet( Metadata metadata = generateMetaDataTemplate(page, pageSize); List data = germplasmService.findGermplasm(germplasmPUI, germplasmDbId, germplasmName, accessionNumber, collection, binomialName, genus, species, trialDbId, studyDbId, synonym, parentDbId, - progenyDbId, commonCropName, programDbId, externalReferenceId, externalReferenceID, + progenyDbId, commonCropName, programDbId, programName, externalReferenceId, externalReferenceID, externalReferenceSource, metadata); return responseOK(new GermplasmListResponse(), new GermplasmListResponseResult(), data, metadata); } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/handlers/GermplasmListSearchRequestHandler.java b/src/main/java/org/brapi/test/BrAPITestServer/handlers/GermplasmListSearchRequestHandler.java new file mode 100644 index 00000000..b1d731b7 --- /dev/null +++ b/src/main/java/org/brapi/test/BrAPITestServer/handlers/GermplasmListSearchRequestHandler.java @@ -0,0 +1,37 @@ +package org.brapi.test.BrAPITestServer.handlers; + +import io.swagger.model.Metadata; +import io.swagger.model.core.*; +import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; +import org.brapi.test.BrAPITestServer.service.germ.GermplasmService; +import org.springframework.stereotype.Component; + +import java.util.List; + +@Component +public class GermplasmListSearchRequestHandler implements ListItemSearchRequestHandler { + private final GermplasmService germplasmService; + + public GermplasmListSearchRequestHandler(GermplasmService germplasmService) { + this.germplasmService = germplasmService; + } + + @Override + public ListTypes getListType() { + return ListTypes.GERMPLASM; + } + + @Override + public Class getSearchRequestClass() { + return GermplasmListSearchRequest.class; + } + + @Override + public List> search( + ListDetails list, + GermplasmListSearchRequest searchRequest, + Metadata metadata) throws BrAPIServerException { + + return germplasmService.findGermplasmByList(list, searchRequest, metadata); + } +} diff --git a/src/main/java/org/brapi/test/BrAPITestServer/handlers/ListItemSearchRequestHandler.java b/src/main/java/org/brapi/test/BrAPITestServer/handlers/ListItemSearchRequestHandler.java new file mode 100644 index 00000000..29e3481f --- /dev/null +++ b/src/main/java/org/brapi/test/BrAPITestServer/handlers/ListItemSearchRequestHandler.java @@ -0,0 +1,31 @@ +package org.brapi.test.BrAPITestServer.handlers; + +import io.swagger.model.Metadata; +import io.swagger.model.core.ListDetails; +import io.swagger.model.core.ListItemWithFullItem; +import io.swagger.model.core.ListTypes; +import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; + +import java.util.List; + +// TODO: Implement for every available list type. For now, Germplasm is the only implementation required by DeltaBreed. +/** + * This is a generic interface for any list item search for any list type to implement. + * + * This interface is designed to have implementors pass a EntityListSearchRequest, like GermplasmListSearchRequest, as the parameterized object. + * The implementations must then provide the intended ListTypes enum value for this request, the EntityListSearchRequest class object, + * and a dedicated search method to carry out the search. + * + * See ListsApiController.searchListByItemRequest(), ListItemService.search() for usages, and GermplasmListSearchRequestHandler for an implementation. + */ +public interface ListItemSearchRequestHandler { + ListTypes getListType(); + + Class getSearchRequestClass(); + + List> search( + ListDetails list, + T searchRequest, + Metadata metadata + ) throws BrAPIServerException; +} diff --git a/src/main/java/org/brapi/test/BrAPITestServer/model/dto/EntityType.java b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/EntityType.java new file mode 100644 index 00000000..10cd9c20 --- /dev/null +++ b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/EntityType.java @@ -0,0 +1,11 @@ +package org.brapi.test.BrAPITestServer.model.dto; + +public enum EntityType { + TEXT, + UUID, + BOOLEAN, + // Sorting is done at the database schema/formula level for numbers. See GermplasmEntity.maleParentGid. No changes to filtering required for this datatype. + NUMBER, + DATE + // Add any other entity data types we should filter different in SearchQueryBuilder here +} diff --git a/src/main/java/org/brapi/test/BrAPITestServer/model/dto/SortAndFilterEntityColumnInfo.java b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/SortAndFilterEntityColumnInfo.java new file mode 100644 index 00000000..60cd42ed --- /dev/null +++ b/src/main/java/org/brapi/test/BrAPITestServer/model/dto/SortAndFilterEntityColumnInfo.java @@ -0,0 +1,53 @@ +package org.brapi.test.BrAPITestServer.model.dto; + +/** + * This class is used to map an entity's column name to the SQL type of lookup that should be completed for filter searches. + * The entityColumnName is also used for sorts as well. + */ +public class SortAndFilterEntityColumnInfo { + private final String entityColumnName; + private final EntityType entityType; + // This boolean tells us effectively if the column is sortable. Hibernate does not support sorting on collections, as it is confusing. + // If this feature is desired, a new subquery would likely have to be created to achieve this on the collection. + // See SearchQueryBuilder.sortBy() for usage. + private final boolean isCollectionOnEntity; + // This boolean tells us if the column has been joined on a table that does not exist in the target entity. + // In this case it's likely we want different join logic, see SearchQueryBuilder.sortBy or .filterBy for usages + private final boolean isJoinOnUnrelatedEntity; + + + public SortAndFilterEntityColumnInfo(String entityColumnName, EntityType entityType) { + this.entityColumnName = entityColumnName; + this.entityType = entityType; + this.isCollectionOnEntity = false; + this.isJoinOnUnrelatedEntity = false; + } + + public SortAndFilterEntityColumnInfo(String entityColumnName, EntityType entityType, boolean isCollectionOnEntity, boolean isJoinOnUnrelatedEntity) { + this.entityColumnName = entityColumnName; + this.entityType = entityType; + this.isCollectionOnEntity = isCollectionOnEntity; + this.isJoinOnUnrelatedEntity = isJoinOnUnrelatedEntity; + } + + public String getEntityColumnName() { + return entityColumnName; + } + + public EntityType getEntityType() { + return entityType; + } + + public boolean isCollectionOnEntity() { + return isCollectionOnEntity; + } + + public boolean isJoinOnUnrelatedEntity() { + return isJoinOnUnrelatedEntity; + } + + @Override + public String toString() { + return this.entityColumnName; + } +} diff --git a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/ListItemEntity.java b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/ListItemEntity.java index 92b76da3..3b553823 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/ListItemEntity.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/ListItemEntity.java @@ -3,6 +3,7 @@ import jakarta.persistence.*; import org.brapi.test.BrAPITestServer.model.entity.BrAPIBaseEntity; +import org.hibernate.annotations.Formula; import org.hibernate.annotations.Where; @Entity @@ -17,6 +18,8 @@ public class ListItemEntity extends BrAPIBaseEntity { private Integer position; @Column(name = "soft_deleted") private boolean softDeleted; + @Formula("position + 1") + private Integer positionIndexedBy1; public ListEntity getList() { return list; @@ -38,4 +41,16 @@ public void setPosition(Integer position) { } public boolean getSoftDeleted() { return softDeleted; } public void setSoftDeleted(boolean softDeleted) { this.softDeleted = softDeleted; } + + public boolean isSoftDeleted() { + return softDeleted; + } + + public Integer getPositionIndexedBy1() { + return positionIndexedBy1; + } + + public void setPositionIndexedBy1(Integer positionIndexedBy1) { + this.positionIndexedBy1 = positionIndexedBy1; + } } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/TrialEntity.java b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/TrialEntity.java index 1c9be57a..5f9bb989 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/TrialEntity.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/core/TrialEntity.java @@ -4,8 +4,10 @@ import org.brapi.test.BrAPITestServer.model.entity.BrAPIPrimaryEntity; import org.brapi.test.BrAPITestServer.model.entity.pheno.ObservationEntity; import org.brapi.test.BrAPITestServer.model.entity.pheno.ObservationUnitEntity; +import org.hibernate.annotations.Formula; import org.hibernate.annotations.Where; +import java.time.OffsetDateTime; import java.util.Date; import java.util.List; @Entity @@ -38,6 +40,12 @@ public class TrialEntity extends BrAPIPrimaryEntity { @Column(name = "soft_deleted") private boolean softDeleted; + @Formula("(additional_info #>> '{createdDate}')") + private String createdDate; + + @Formula("(additional_info #>> '{createdBy,userName}')") + private String createdBy; + @ManyToOne(fetch = FetchType.LAZY) private CropEntity crop; @ManyToOne(fetch = FetchType.LAZY) diff --git a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/germ/GermplasmEntity.java b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/germ/GermplasmEntity.java index 1c5192db..cbf15440 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/model/entity/germ/GermplasmEntity.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/model/entity/germ/GermplasmEntity.java @@ -9,11 +9,14 @@ import org.brapi.test.BrAPITestServer.model.entity.BrAPIPrimaryEntity; import org.brapi.test.BrAPITestServer.model.entity.SearchRequestEntity; import org.brapi.test.BrAPITestServer.model.entity.core.CropEntity; +import org.brapi.test.BrAPITestServer.model.entity.core.ProgramEntity; import org.brapi.test.BrAPITestServer.model.entity.germ.GermplasmInstituteEntity.InstituteTypeEnum; import org.brapi.test.BrAPITestServer.model.entity.pheno.ObservationUnitEntity; import org.brapi.test.BrAPITestServer.model.entity.pheno.TaxonEntity; import org.hibernate.annotations.BatchSize; +import org.hibernate.annotations.Collate; +import org.hibernate.annotations.Formula; import org.hibernate.annotations.Where; import java.util.ArrayList; @@ -24,8 +27,9 @@ @Table(name = "germplasm") @Where(clause = "soft_deleted = false") public class GermplasmEntity extends BrAPIPrimaryEntity { - @Column - private String accessionNumber; + @Collate(value = "natural_sort") + @Column(name = "accession_number", nullable = false) + private String accessionNumber = ""; @Column private Date acquisitionDate; @Column @@ -43,8 +47,9 @@ public class GermplasmEntity extends BrAPIPrimaryEntity { private String countryOfOriginCode; @ManyToOne(cascade = CascadeType.DETACH, fetch = FetchType.LAZY) private CropEntity crop; - @Column - private String defaultDisplayName; + @Collate(value = "natural_sort") + @Column(name = "default_display_name", nullable = false) + private String defaultDisplayName = ""; @Column private String documentationURL; @OneToMany(mappedBy = "germplasm", cascade = CascadeType.ALL) @@ -71,8 +76,9 @@ public class GermplasmEntity extends BrAPIPrimaryEntity { @ManyToMany @JoinTable private List searchResults; - @Column - private String seedSource; + @Collate(value = "natural_sort") + @Column(name = "seed_source", nullable = false) + private String seedSource = ""; @Column private String seedSourceDescription; @Column @@ -96,6 +102,32 @@ public class GermplasmEntity extends BrAPIPrimaryEntity { private List typeOfGermplasmStorageCode; @Column(name = "soft_deleted") private boolean softDeleted; + @ManyToOne(cascade = CascadeType.DETACH, fetch = FetchType.LAZY) + private ProgramEntity program; + + @Column(name = "created_date", insertable = false, updatable = false) + private Date createdDate; + + @Collate(value = "natural_sort") + @Column(name = "created_by", insertable = false, updatable = false) + private String createdBy; + + // BI is currently not using BrAPI's breeding_method table, and is storing the data in additional_info. + // This column is being used for sorting/filtering in the meantime to get the collate/not null required for front end sorting + @Collate(value = "natural_sort") + @Column(name = "breeding_method_sort", insertable = false, updatable = false) + private String methodName; + + @Collate(value = "natural_sort") + @Column(name = "female_parent_gid", insertable = false, updatable = false) + private String femaleParentGid; + + @Collate(value = "natural_sort") + @Column(name = "male_parent_gid", insertable = false, updatable = false) + private String maleParentGid; + + @Formula("cast(additional_info #>> '{importEntryNumber}' AS INTEGER)") + private Integer importEntryNumber; public GermplasmInstituteEntity getHostInstitute() { if (getInstitutes() != null) { @@ -368,4 +400,12 @@ public void setTypeOfGermplasmStorageCode(List typeOf public void setSoftDeleted(boolean sofDeleted) { this.softDeleted = sofDeleted; } + public ProgramEntity getProgram() { + return program; + } + + public void setProgram(ProgramEntity program) { + this.program = program; + } + } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepository.java b/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepository.java index dd76d8f4..98ae8f25 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepository.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepository.java @@ -5,6 +5,7 @@ import java.util.Optional; import java.util.UUID; +import jakarta.persistence.Tuple; import org.brapi.test.BrAPITestServer.exceptions.InvalidPagingException; import org.brapi.test.BrAPITestServer.model.entity.BrAPIPrimaryEntity; import org.brapi.test.BrAPITestServer.service.SearchQueryBuilder; @@ -27,10 +28,12 @@ public interface BrAPIRepository S save(S entity); public List saveAll(Iterable entities); - + public void refresh(S entity); public void fetchXrefs(List page, Page pagedEntities, Class searchClass) throws InvalidPagingException; List findByIdIn(List ids); + + public Page findAllBySearchAndPaginateMultipleEntitySelect(SearchQueryBuilder searchQuery, Pageable pageReq) throws InvalidPagingException; } \ No newline at end of file diff --git a/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepositoryImpl.java b/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepositoryImpl.java index 583a28cf..b0977e7c 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepositoryImpl.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/repository/primaryEntities/BrAPIRepositoryImpl.java @@ -9,6 +9,7 @@ import java.util.stream.Collectors; import jakarta.persistence.EntityManager; +import jakarta.persistence.Tuple; import jakarta.persistence.TypedQuery; import org.brapi.test.BrAPITestServer.exceptions.InvalidPagingException; @@ -59,6 +60,38 @@ public Page findAllBySearchAndPaginate(SearchQueryBuilder searchQuery, Pag return new PageImpl<>(content, pageReq, totalCount); } + /** + * Supports paginated queries that select on multiple entities, like this: + * + * SELECT listItem, entity FROM GermplasmEntity entity + * JOIN ListItemEntity listItem ON listItem.item = entity.germplasmName + * + * The resulting Page represents each entity as an element in the tuple from the select, so in the example above, + * tuple.get(0) = ListItemEntity + * tuple.get(1) = GermplasmEntity + * + * This is helpful when there are requirements to sort/filter/paginate an entity in relation to another object, which is the exact + * use case for ListsApiController.searchListByItemRequest(). + * + * For example usages of this method, see GermplasmService.findGermplasmByList() + */ + public Page findAllBySearchAndPaginateMultipleEntitySelect(SearchQueryBuilder searchQuery, Pageable pageReq) throws InvalidPagingException { + applyUserId(searchQuery); + + Long totalCount = getMultipleSelectCountQuery(searchQuery); + + validatePageNumber(pageReq, totalCount); + + if (totalCount == 0) { + // Short-circuit to avoid running possible long-running query + return new PageImpl<>(Collections.emptyList(), pageReq, totalCount); + } + + List content = getPagedContentMultipleEntitySelect(searchQuery, pageReq); + + return new PageImpl<>(content, pageReq, totalCount); + } + /** * This method should be used when there is a need to page entities that are complex and have lots of lazily loaded, * one-to-many collection attributes. Call this method with the query you've built. @@ -73,6 +106,7 @@ public Page findAllBySearchAndPaginate(SearchQueryBuilder searchQuery, Pag * If the need is to fetch according to an entirely different base criteria, feel free to call this method again. * * The results will be paged and ordered based on the submitted searchQuery and pageReq. + * TODO: This method and it's confusing use of SearchQueryBuilder.idQuery may not be necessary at all if we keep left join fetches out of initial queries and fetch after. */ public Page findAllBySearchPaginatingWithFetches(SearchQueryBuilder searchQuery, Pageable pageReq) throws InvalidPagingException { @@ -181,6 +215,17 @@ private List getPagedContent(SearchQueryBuilder searchQuery, Pageable page return query.getResultList(); } + private List getPagedContentMultipleEntitySelect(SearchQueryBuilder searchQuery, Pageable pageReq) { + TypedQuery query = entityManager.createQuery(searchQuery.getQuery(), Tuple.class); + + setQueryParamsMultipleEntitySelect(query, searchQuery); + + query.setFirstResult((int) pageReq.getOffset()); + query.setMaxResults(pageReq.getPageSize()); + + return query.getResultList(); + } + private List searchEntitiesWithIds(SearchQueryBuilder searchQuery, List ids) { searchQuery.appendList(ids.stream().map(Object::toString).collect(Collectors.toList()), "id"); @@ -205,6 +250,12 @@ private void setQueryParams(TypedQuery query, SearchQueryBuilder searchQue } } + private void setQueryParamsMultipleEntitySelect(TypedQuery query, SearchQueryBuilder searchQuery) { + for (Entry entry : searchQuery.getParams().entrySet()) { + query.setParameter(entry.getKey(), entry.getValue()); + } + } + private List getPagedContentIdsOnly(SearchQueryBuilder searchQuery, Pageable pageReq) { TypedQuery query = entityManager.createQuery(searchQuery.getIdQuery(), UUID.class); @@ -220,6 +271,19 @@ private List getPagedContentIdsOnly(SearchQueryBuilder searchQuery, Pag } + private Long getMultipleSelectCountQuery(SearchQueryBuilder searchQuery) + { + TypedQuery query = entityManager.createQuery(searchQuery.getCountQueryMultipleSelect(), Long.class); + for (Entry entry : searchQuery.getParams().entrySet()) { + query.setParameter(entry.getKey(), entry.getValue()); + } + + List content = query.getResultList(); + if (!content.isEmpty()) { + return content.getFirst(); + } + return 0L; + } private Long getTotalCount(SearchQueryBuilder searchQuery) { @@ -240,10 +304,12 @@ private Long getTotalCount(SearchQueryBuilder searchQuery) { return 0L; } - private void validatePageNumber(Pageable pageReq, Long totalCount) throws InvalidPagingException { - int reqPageNum = pageReq.getPageNumber(); - if (reqPageNum != 0 && reqPageNum > Math.floor(((double) totalCount) / pageReq.getPageSize())) { - // Condition indicates a request was sent where the page requested exceeds the total number of pages. + static void validatePageNumber(Pageable pageReq, Long totalCount) throws InvalidPagingException { + int requestedPage = pageReq.getPageNumber(); + long totalPages = (long) Math.ceil(totalCount / (double) pageReq.getPageSize()); + + // Condition indicates a request was sent where the page requested exceeds the total number of pages. + if (requestedPage > 0 && requestedPage >= totalPages) { // Instruct requester to send the correct request. throw new InvalidPagingException(); } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/SearchQueryBuilder.java b/src/main/java/org/brapi/test/BrAPITestServer/service/SearchQueryBuilder.java index 80bf5bc5..62a50ad3 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/service/SearchQueryBuilder.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/SearchQueryBuilder.java @@ -6,27 +6,43 @@ import java.time.LocalDate; import java.time.OffsetDateTime; +import io.swagger.model.FilterBy; import io.swagger.model.GeoJSONSearchArea; -import io.swagger.model.core.SortOrder; +import io.swagger.model.sort.SortBy; +import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; +import org.brapi.test.BrAPITestServer.model.dto.SortAndFilterEntityColumnInfo; +import org.brapi.test.BrAPITestServer.model.dto.EntityType; +import org.springframework.http.HttpStatus; public class SearchQueryBuilder { private String selectClause; private String selectOnlyIds; + private String selectOnlyIdsSubquery; + private String joinClause; + private String joinClauseIdSubquery; private String whereClause; private String defaultSort; private String sortClause; private Map params; + private List joinedTables = new ArrayList<>(); + private List joinedFetchedTables = new ArrayList<>(); private Class clazz; - - public SearchQueryBuilder(Class clazz) { - this.selectClause = "SELECT distinct entity FROM " + clazz.getSimpleName() + " entity "; - this.selectOnlyIds = "SELECT distinct entity.id FROM " + clazz.getSimpleName() + " entity "; + private final String default_date = "1970-01-01"; + + public SearchQueryBuilder(Class baseEntity) { + this.selectClause = "SELECT distinct entity FROM " + baseEntity.getSimpleName() + " entity "; + // This is the top level query for selectOnlyIds. It is used to construct the full id query in getIdQuery() + this.selectOnlyIds = "SELECT entity.id FROM " + baseEntity.getSimpleName() + " entity "; + // This subquery will contain all the joins and filters necessary for the selectOnlyIds query and protects against duplicates using distinct + this.selectOnlyIdsSubquery = "SELECT distinct entity2.id FROM " + baseEntity.getSimpleName() + " entity2 "; + this.joinClause = ""; + this.joinClauseIdSubquery = ""; this.whereClause = "WHERE 1=1 "; this.defaultSort = " ORDER BY entity.id ASC "; this.sortClause = ""; this.params = new HashMap<>(); - this.clazz = clazz; + this.clazz = baseEntity; } public String getQuery() { @@ -35,16 +51,65 @@ public String getQuery() { sortClause = defaultSort; } - return selectClause + whereClause + sortClause; + return selectClause + joinClause + whereClause + sortClause; + } + + public String getCountQueryMultipleSelect() { + String firstSelection = selectClause + .replaceFirst("(?i)^SELECT\\s+(?:DISTINCT\\s+)?", "") + .split(",")[0] + .trim(); + + int fromIndex = selectClause.toUpperCase(Locale.ROOT).indexOf(" FROM "); + + String fromClause = selectClause.substring(fromIndex); + + return "SELECT COUNT(DISTINCT " + firstSelection + ".id) " + + fromClause + + joinClause.replaceAll("(?i)LEFT JOIN FETCH", "LEFT JOIN") + + whereClause; } + /** + * The goal of this query is to return a query that will return only the BrAPI dbIds of the source entity, applying + * sorting, filtering, and pagination to the query. + * + * This has to be done in a very deliberate way because of both HQL and postgres constraints, so this query should + * end up looking something like this: + * + * SELECT entity.id + * FROM GermplasmEntity entity + * WHERE entity.id IN ( + * SELECT distinct entity2.id + * FROM GermplasmEntity entity2 + * JOIN entity2.externalReferences externalReference + * WHERE 1=1 AND externalReference.externalReferenceId in :externalReferenceId + * AND externalReference.externalReferenceSource in :externalReferenceSource + * AND entity2.program.id in :program_id + * ) + * ORDER BY entity.id ASC + * + * By containing the filtering and the joining in a subquery with a DISTINCT, we can control potential duplicates from breaking through the cracks. + * Then we can apply sorting outside of this query without a distinct to avoid postgres's requirement to include every order by column in the select clause. + * Distinct is not an issue here, since we are selecting only on id, which is always unique. + */ public String getIdQuery() { if (sortClause.isEmpty()) { // By default, sort on entity id to have query result remain idempotent sortClause = defaultSort; } - return selectOnlyIds + whereClause + sortClause; + // Now build the subquery to apply all the same filters/joins built up on the original entity with the inner entity. + + // To do this, create a regex expression which can be used to identity all instances of an "entity" without any proceeding + // words, dots, underscores, or colons, and ignore any existing instances of entity2, which exists already in selectOnlyIdsSubquery + String entityRegex = "(? getParams() { @@ -55,6 +120,13 @@ public Class getClazz() { return clazz; } + public SearchQueryBuilder modifySelect(List entityAliases) { + + this.selectClause = "SELECT distinct " + String.join(", ", entityAliases) + " FROM " + clazz.getSimpleName() + " entity "; + + return this; + } + public SearchQueryBuilder appendList(List list, String columnName) { String paramName = paramFilter(columnName); if (list != null && !list.isEmpty()) { @@ -133,6 +205,39 @@ public SearchQueryBuilder appendSingle(UUID single, String columnName) { return this; } + public SearchQueryBuilder appendLike(String like, String columnName) { + String paramName = paramFilterPattern(columnName); + + if (like != null) { + this.whereClause += "AND lower(" + entityPrefix(columnName) + ") LIKE :" + paramName + " "; + this.params.put(paramName, "%" + like + "%"); + } + return this; + } + + // Used to convert non-string fields to string and use a like filter comparison + public SearchQueryBuilder appendLikeString(String like, String columnName) { + String paramName = paramFilterPattern(columnName); + + if (like != null) { + this.whereClause += "AND cast(" + entityPrefix(columnName) + " as String) LIKE :" + paramName + " "; + this.params.put(paramName, "%" + like + "%"); + } + return this; + } + + public SearchQueryBuilder appendLikeDate(String like, String columnName) { + String paramName = paramFilterPattern(columnName); + + if (like != null) { + this.whereClause += " AND to_char(" + entityPrefix(columnName) + ", 'YYYY-MM-DD') LIKE :" + paramName + " " + + // Ensure we do not filter against the default date, which is effectively a NULL value for DeltaBreed's system. + " AND to_char(" + entityPrefix(columnName) + ", 'YYYY-MM-DD') <> '" + default_date + "' "; + this.params.put(paramName, "%" + like + "%"); + } + return this; + } + public > SearchQueryBuilder appendEnum(E enumVal, String columnName) { String paramName = paramFilter(columnName); if (enumVal != null) { @@ -258,13 +363,42 @@ public SearchQueryBuilder withExRefs(List exRefIds, List exRe } public SearchQueryBuilder join(String join, String name) { - this.selectClause += "JOIN " + entityPrefix(join) + " " + paramFilter(name) + " "; - this.selectOnlyIds += "JOIN " + entityPrefix(join) + " " + paramFilter(name) + " "; + + if (!this.joinedTables.contains(join) && !this.joinedFetchedTables.contains(join)) { + this.joinClause += "JOIN " + entityPrefix(join) + " " + paramFilter(name) + " "; + this.joinClauseIdSubquery += "JOIN " + entityPrefix(join) + " " + paramFilter(name) + " "; + this.joinedTables.add(join); + } else if (joinedFetchedTables.contains(join) && !this.joinedTables.contains(join)) { + this.joinClauseIdSubquery += "JOIN " + entityPrefix(join) + " " + paramFilter(name) + " "; + } + return this; + } + + public SearchQueryBuilder joinEntity(Class joinedEntity, + String alias, + String onClause) { + this.joinClause += " JOIN " + joinedEntity.getSimpleName() + + " " + alias + + " ON " + onClause; return this; } public SearchQueryBuilder leftJoinFetch(String join, String name) { - this.selectClause += generateLeftJoinFetch(join, name); + return leftJoinFetch(join, name, false); + } + + public SearchQueryBuilder leftJoinFetch(String join, String name, boolean overrideExistingJoin) { + + if (this.joinedTables.contains(join) && overrideExistingJoin) { + // Override existing normal join with join fetch if it already exists in a query + // This override does not change the alias to the name provided, and assumes further usages will use the same alias. + this.joinClause = this.joinClause.replace("JOIN " + entityPrefix(join), "LEFT JOIN FETCH " + entityPrefix(join)); + this.joinedFetchedTables.add(join); + this.joinedTables.remove(join); + } else if (!this.joinedFetchedTables.contains(join)) { + this.joinClause += generateLeftJoinFetch(join, name); + this.joinedFetchedTables.add(join); + } return this; } @@ -277,8 +411,11 @@ public SearchQueryBuilder removeAndReplaceLeftJoinFetch(String join, String existingJoin, String existingName) { - this.selectClause = - this.selectClause.replace(generateLeftJoinFetch(existingJoin, existingName), generateLeftJoinFetch(join, name)); + this.joinClause = + this.joinClause.replace(generateLeftJoinFetch(existingJoin, existingName), generateLeftJoinFetch(join, name)); + + this.joinedFetchedTables.remove(existingJoin); + this.joinedFetchedTables.add(join); return this; } @@ -288,8 +425,9 @@ public SearchQueryBuilder removeAndReplaceLeftJoinFetch(String join, * base query criteria to add another join fetch with leftJoinFetch() */ public SearchQueryBuilder removeLeftJoinFetch(String join, String name) { - this.selectClause = - this.selectClause.replace(generateLeftJoinFetch(join, name), ""); + this.joinClause = + this.joinClause.replace(generateLeftJoinFetch(join, name), ""); + this.joinedFetchedTables.remove(join); return this; } @@ -297,6 +435,8 @@ private String generateLeftJoinFetch(String join, String paramName) { return "LEFT JOIN FETCH " + entityPrefix(join) + " " + paramFilter(paramName) + " "; } + // Here * is used as a trigger to use the subsequent field string after it directly on a hibernate query instead of + // entity.field. This is important in many query builds, including filter/sort queries private String entityPrefix(String field) { if (field.startsWith("*")) { return field.substring(1); @@ -311,14 +451,121 @@ private String paramFilter(String param) { return param.replace('.', '_').replace('*', '_'); } - public SearchQueryBuilder withSort(String sortByStr, SortOrder sortOrder) { - String sortOrderStr = "ASC"; - if (sortOrder != null) { - sortOrderStr = sortOrder.toString(); + private String paramFilterPattern(String param) { + if (param == null) + return ""; + return param.replace('.', '_').replace('*', '_') + "Pattern"; + } + + /** + * Takes a list of SortBy options that should typically come in a searchRequest, along with a map of the validated + * columns names. + * Applies the entries in the list to sort the SearchQuery. + * + * A SortBy has + * - A column name + * - An order (DESC, ASC) + */ + public SearchQueryBuilder sortBy(List sortBy, Map entityColInfoBySubmittedName) throws BrAPIServerException { + + if (sortBy == null || sortBy.isEmpty()) { + return this; + } + + for (SortBy sort : sortBy) { + // At this point, the submitted sortBy name has been verified to be in entityColInfoBySubmittedName + SortAndFilterEntityColumnInfo sortAndFilterEntityColumnInfo = entityColInfoBySubmittedName.get(sort.getSortedOn()); + + String entityColName = sortAndFilterEntityColumnInfo.getEntityColumnName(); + + if (sortAndFilterEntityColumnInfo.isCollectionOnEntity()) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "Sorting on one to many relationships not supported"); + } + + String[] split = entityColName.split("\\."); + + if (split.length > 2) { + // TODO: Implement this if it becomes a requirement + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "Sorting on a table greater than one level from primary entity not allowed"); + } + + if (split.length == 2 && !split[1].equals("id") && !sortAndFilterEntityColumnInfo.isJoinOnUnrelatedEntity()) { + // Avoid extra/overriding joins in the case where an unrelated entity has been joined, like the ListItemEntity use case in GermplasmService.searchGermplasmByList() + leftJoinFetch(split[0], split[0], true); + } + + sort.setSortedOn(entityColName); + + if (sortBy.getFirst().equals(sort)) { + this.sortClause += " ORDER BY "; + buildSort(sort); + } else { + this.sortClause += ", "; + buildSort(sort); + } } - this.sortClause += " ORDER BY " + entityPrefix(sortByStr) + " " + sortOrderStr; + return this; + } + // Used to continue utilizing the same search query, like in GermplasmService fetching without pagination use case + public SearchQueryBuilder resetSortClause() { + this.sortClause = ""; return this; } + + private void buildSort(SortBy sort) { + this.sortClause += entityPrefix(sort.getSortedOn()) + " " + sort.getSortOrder() + " "; + } + + /** + * Takes a list of FilterBy options that should typically come in a searchRequest, along with a map of the validated + * columns names and the data type they represent for accurate filtering on different data types. + * Applies the entries in the list to filter the SearchQuery. + * + * A FilterBy has + * - A column name + * - A value which the column name should be filtered on + */ + public SearchQueryBuilder filterBy(List filterBy, Map entityColAndTypeBySubmittedName) throws BrAPIServerException { + SearchQueryBuilder searchQuery = this; + + if (filterBy == null || filterBy.isEmpty()) { + return searchQuery; + } + + for (FilterBy filter : filterBy) { + // At this point, the submitted filterBy column name has been verified to be in entityColAndTypeBySubmittedName + SortAndFilterEntityColumnInfo sortAndFilterEntityColumnInfo = entityColAndTypeBySubmittedName.get(filter.getFilterOn()); + + if (sortAndFilterEntityColumnInfo.isCollectionOnEntity() && !sortAndFilterEntityColumnInfo.isJoinOnUnrelatedEntity()) { + // Avoid extra/overriding joins in the case where an unrelated entity has been joined, like the ListItemEntity use case in GermplasmService.searchGermplasmByList() + joinCollectionColumn(sortAndFilterEntityColumnInfo.getEntityColumnName()); + } + + if (sortAndFilterEntityColumnInfo.getEntityType() == EntityType.TEXT) { + searchQuery = appendLike(filter.getValue().toLowerCase(), sortAndFilterEntityColumnInfo.getEntityColumnName()); + } else if (sortAndFilterEntityColumnInfo.getEntityType() == EntityType.UUID) { + searchQuery = appendLikeString(filter.getValue(), sortAndFilterEntityColumnInfo.getEntityColumnName()); + } else if (sortAndFilterEntityColumnInfo.getEntityType() == EntityType.NUMBER) { + // Compare as String exact match for numbers, in case users send non-numeric characters. + searchQuery = appendSingle(filter.getValue(), sortAndFilterEntityColumnInfo.getEntityColumnName()); + } else if (sortAndFilterEntityColumnInfo.getEntityType() == EntityType.DATE) { + searchQuery = appendLikeDate(filter.getValue(), sortAndFilterEntityColumnInfo.getEntityColumnName()); + } + } + + return searchQuery; + } + + /** + * This helper method joins the table that a collection column name is related to if it doesn't exist already. + * This is particularly important for filter search requests because if the join doesn't exist, and it is referenced + * the query will not execute. + */ + private void joinCollectionColumn(String submittedSortFilterColumnName) { + String joinTableName = submittedSortFilterColumnName.substring(1, submittedSortFilterColumnName.indexOf(".")); + + this.join(joinTableName, joinTableName); + } } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/core/ListItemService.java b/src/main/java/org/brapi/test/BrAPITestServer/service/core/ListItemService.java new file mode 100644 index 00000000..1c846e07 --- /dev/null +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/core/ListItemService.java @@ -0,0 +1,114 @@ +package org.brapi.test.BrAPITestServer.service.core; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException; +import io.swagger.model.Metadata; +import io.swagger.model.core.*; +import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; +import org.brapi.test.BrAPITestServer.handlers.ListItemSearchRequestHandler; +import org.springframework.http.HttpStatus; +import org.springframework.http.converter.HttpMessageNotReadableException; +import org.springframework.stereotype.Service; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +@Service +public class ListItemService { + private final ListService listService; + private final Map> handlers; + private final ObjectMapper objectMapper; + + public ListItemService(ListService listService, + List> handlerList, + ObjectMapper objectMapper) { + this.listService = listService; + this.objectMapper = objectMapper; + // Initializes all ListItemSearchRequestHandlers by enumerating through the available BrAPI ListTypes. + // Right now, GermplasmListSearchRequestHandler is the only implementation available. + this.handlers = handlerList.stream() + .collect(Collectors.toMap( + ListItemSearchRequestHandler::getListType, + Function.identity() + )); + } + + public List> search(ListDetails list, + JsonNode searchRequest, + Metadata metadata) throws BrAPIServerException { + ListItemSearchRequestHandler handler = handlers.get(list.getListType()); + + if (handler == null) { + // List Type does not have a handler yet. Implement ListItemSearchRequestHandler for the BrAPI ListType, using GermplasmListSearchRequestHandler as an example. + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, "Unsupported list type: " + list.getListType()); + } + + return executeHandler(handler, list, searchRequest, metadata); + } + + private List> executeHandler(ListItemSearchRequestHandler handler, + ListDetails list, + JsonNode request, + Metadata metadata) throws BrAPIServerException { + + T typedSearchRequest; + + validateSearchRequest(list, request, handler); + + try { + typedSearchRequest = objectMapper.convertValue( + request, + handler.getSearchRequestClass() + ); + } catch (IllegalArgumentException e) { + // This allows us to emulate the 400 request failures that normally propagate to the BrapiExceptionHandler.handleHttpMessageNotReadable() + // This is needed because of the generic nature of the EntityListSearchRequest objects, which come in as untyped JsonNode objects. + // To support EntityListSearchRequest objects of any type, the jackson serialization has to be done after where it normally occurs at the filter level. + // Throwing this type of exception obfuscates this fact, and if there are serialization/parsing issues we should see the same error messages we would normally see + // if done at the filter level. + throw new HttpMessageNotReadableException("Could not convert request object to JSON object.", e); + } + + return handler.search(list, typedSearchRequest, metadata); + } + + /** + * Ensures submitted request contains fields/properties only relevant to the BrAPI search request for the list type. + */ + private void validateSearchRequest(ListDetails list, JsonNode request, ListItemSearchRequestHandler handler) throws BrAPIServerException { + + ObjectReader reader = objectMapper + .readerFor(handler.getSearchRequestClass()) + .with(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); + + + try (JsonParser parser = request.traverse(objectMapper)) { + reader.readValue(parser); + } catch (UnrecognizedPropertyException e) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, + String.format("List with dbId [%s] is of type [%s]. The expected search request to be submitted to this endpoint is a " + + "[%s], but a search request property [%s] was found that does not exist in the allowed search request for this list type. " + + "Please ensure any fields being searched match the schema of a [%s] exactly before submitting to ensure correct data is retrieved.", + list.getListDbId(), + list.getListType(), + handler.getSearchRequestClass().getSuperclass().getSimpleName(), + e.getPropertyName(), + handler.getSearchRequestClass().getSuperclass().getSimpleName()) + ); + } catch (IOException e) { + throw new BrAPIServerException(HttpStatus.BAD_REQUEST, + String.format("List with dbId [%s] is of type [%s]. The expected search request to be submitted to this endpoint is a " + + "[%s], but a part of the request is malformed so that it is incompatible with the targeted request type." + + "Please ensure any fields being searched match the schema of a [%s] exactly before submitting to ensure correct data is retrieved.", + list.getListDbId(), + list.getListType(), + handler.getSearchRequestClass().getSuperclass().getSimpleName(), + handler.getSearchRequestClass().getSuperclass().getSimpleName()) + ); + } + } +} diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/core/ProgramService.java b/src/main/java/org/brapi/test/BrAPITestServer/service/core/ProgramService.java index 720f731b..9f11a8f7 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/service/core/ProgramService.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/core/ProgramService.java @@ -1,9 +1,7 @@ package org.brapi.test.BrAPITestServer.service.core; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import java.util.UUID; +import java.util.*; +import java.util.stream.Collectors; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerDbIdNotFoundException; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; @@ -76,14 +74,33 @@ public List findPrograms(ProgramSearchRequest request, Metadata metadat return programs; } - public List findByIds(List programDbIds) { - var result = new ArrayList(); + public List findByIds(List programDbIds) throws BrAPIServerException { + List result = new ArrayList<>(); if (programDbIds.isEmpty()) { return result; } - return programRepository.findByIdIn(programDbIds.stream().map(UUID::fromString).toList()); + // Dedup programIds by loading into set + Set programDbIdSet = new HashSet<>(programDbIds); + + result = programRepository.findByIdIn(programDbIds.stream().map(UUID::fromString).toList()); + + if (programDbIdSet.size() != result.size()) { + List dbIdsNotFound = new ArrayList<>(); + + Set foundDbIds = result.stream().map(pe -> pe.getId().toString()).collect(Collectors.toSet()); + + programDbIdSet.forEach(dbId -> { + if (!foundDbIds.contains(dbId)) { + dbIdsNotFound.add(dbId); + } + }); + + throw new BrAPIServerException(HttpStatus.NOT_FOUND, String.format("The following submitted programDbIds were not found in the db: [%s]", dbIdsNotFound)); + } + + return result; } public Program getProgram(String programDbId) throws BrAPIServerException { diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/core/StudyService.java b/src/main/java/org/brapi/test/BrAPITestServer/service/core/StudyService.java index 1b6526ea..3995d4f2 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/service/core/StudyService.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/core/StudyService.java @@ -3,10 +3,10 @@ import java.util.*; import java.util.stream.Collectors; +import io.swagger.model.sort.SortBy; import org.apache.commons.lang3.StringUtils; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerDbIdNotFoundException; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerException; -import org.brapi.test.BrAPITestServer.model.entity.BrAPIBaseEntity; import org.brapi.test.BrAPITestServer.model.entity.core.CropEntity; import org.brapi.test.BrAPITestServer.model.entity.core.DataLinkEntity; import org.brapi.test.BrAPITestServer.model.entity.core.EnvironmentParametersEntity; @@ -38,8 +38,7 @@ import io.swagger.model.Metadata; import io.swagger.model.core.Contact; import io.swagger.model.core.EnvironmentParameter; -import io.swagger.model.core.SortBy; -import io.swagger.model.core.SortOrder; +import io.swagger.model.sort.SortOrder; import io.swagger.model.core.Study; import io.swagger.model.core.StudyExperimentalDesign; import io.swagger.model.core.StudyGrowthFacility; @@ -108,10 +107,11 @@ public List findStudies(String commonCropName, String studyType, String p request.addObservationVariableDbIdsItem(observationVariableDbId); if (active != null) request.setActive(active); - if (sortBy != null && SortBy.fromValue(sortBy) != null) - request.setSortBy(SortBy.fromValue(sortBy)); - if (sortOrder != null && SortOrder.fromValue(sortOrder) != null) - request.setSortOrder(SortOrder.fromValue(sortOrder)); + if (sortBy != null) { + SortBy sortByElement = new SortBy(sortBy, SortOrder.fromValue(sortOrder)); + + request.setSortBy(List.of(sortByElement)); + } request.addExternalReferenceItem(externalReferenceId, externalReferenceID, externalReferenceSource); @@ -159,7 +159,8 @@ public List findStudies(StudySearchRequest request, Metadata metaData) .appendList(request.getStudyDbIds(), "id").appendList(request.getStudyNames(), "studyName") .appendList(request.getStudyPUIs(), "studyPUI").appendList(request.getStudyTypes(), "studyType") .appendList(request.getTrialDbIds(), "trial.id").appendList(request.getTrialNames(), "trial.trialName") - .withSort(getSortByField(request.getSortBy()), request.getSortOrder()); + .sortBy(request.getSortByElements(), request.getEntityColInfoBySubmittedNameMap()) + .filterBy(request.getFilterBy(), request.getEntityColInfoBySubmittedNameMap()); Page studiesPage = studyRepository.findAllBySearchAndPaginate(searchQuery, pageReq); PagingUtility.calculateMetaData(metaData, studiesPage); @@ -566,47 +567,4 @@ private EnvironmentParametersEntity convertToEntity(EnvironmentParameter param) return entity; } - private String getSortByField(SortBy sortBy) { - String sortByStr = "id"; - if (sortBy != null) { - switch (sortBy) { - case GERMPLASMDBID: - sortByStr = "*obsunit.germplasm.id"; - break; - case LOCATIONDBID: - sortByStr = "location.id"; - break; - case OBSERVATIONVARIABLEDBID: - sortByStr = "*observation.observationVariable.id"; - break; - case PROGRAMDBID: - sortByStr = "trial.program.id"; - break; - case PROGRAMNAME: - sortByStr = "trial.program.name"; - break; - case SEASONDBID: - sortByStr = "*season.id"; - break; - case STUDYDBID: - sortByStr = "id"; - break; - case STUDYLOCATION: - sortByStr = "location.id"; - break; - case TRIALDBID: - sortByStr = "trial.id "; - break; - case STUDYTYPE: - sortByStr = "studyName"; - break; - case STUDYNAME: - default: - sortByStr = "studyName"; - break; - } - } - return sortByStr; - } - } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/core/TrialService.java b/src/main/java/org/brapi/test/BrAPITestServer/service/core/TrialService.java index fb798a5b..6c3fc54d 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/service/core/TrialService.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/core/TrialService.java @@ -4,6 +4,8 @@ import java.util.stream.Collectors; import io.swagger.model.core.*; +import io.swagger.model.sort.SortBy; +import io.swagger.model.sort.SortOrder; import jakarta.validation.Valid; import org.brapi.test.BrAPITestServer.exceptions.BatchDeleteWrongTypeException; @@ -94,11 +96,10 @@ public List findTrials(@Valid String commonCropName, @Valid String contac request.setSearchDateRangeStart(searchDateRangeStart); if (searchDateRangeEnd != null) request.setSearchDateRangeEnd(searchDateRangeEnd); - if (sortBy != null && SortBy.fromValue(sortBy) != null) - request.setSortBy(SortBy.fromValue(sortBy)); - if (sortOrder != null && SortOrder.fromValue(sortOrder) != null) - request.setSortOrder(SortOrder.fromValue(sortOrder)); - + if (sortBy != null) { + SortBy querySortBy = new SortBy(sortBy, SortOrder.fromValue(sortOrder)); + request.setSortBy(List.of(querySortBy)); + } request.addExternalReferenceItem(externalReferenceId, externalReferenceID, externalReferenceSource); return findTrials(request, metadata); } @@ -113,20 +114,21 @@ public List findTrials(@Valid TrialSearchRequest request, Metadata metada searchQuery = searchQuery.join("contacts", "contact"); } if (request.getStudyDbIds() != null || request.getStudyNames() != null) { - searchQuery = searchQuery.join("studies", "study"); + searchQuery = searchQuery.join("studies", "studies"); } searchQuery = searchQuery.withExRefs(request.getExternalReferenceIDs(), request.getExternalReferenceSources()) .appendList(request.getCommonCropNames(), "crop.cropName") .appendList(request.getContactDbIds(), "*contact.id") - .appendList(request.getLocationDbIds(), "*study.location.id") - .appendList(request.getLocationNames(), "*study.location.locationName") + .appendList(request.getLocationDbIds(), "*studies.location.id") + .appendList(request.getLocationNames(), "*studies.location.locationName") .appendList(request.getProgramDbIds(), "program.id") - .appendList(request.getProgramNames(), "program.name").appendList(request.getStudyDbIds(), "*study.id") - .appendList(request.getStudyNames(), "*study.studyName").appendList(request.getTrialDbIds(), "id") + .appendList(request.getProgramNames(), "program.name").appendList(request.getStudyDbIds(), "*studies.id") + .appendList(request.getStudyNames(), "*studies.studyName").appendList(request.getTrialDbIds(), "id") .appendList(request.getTrialNames(), "trialName") .appendDateRange(request.getSearchDateRangeStart(), request.getSearchDateRangeEnd(), "startDate") - .withSort(getSortByField(request.getSortBy()), request.getSortOrder()); + .sortBy(request.getSortByElements(), request.getEntityColInfoBySubmittedNameMap()) + .filterBy(request.getFilterBy(), request.getEntityColInfoBySubmittedNameMap()); Page trialsPage = trialRepository.findAllBySearchAndPaginate(searchQuery, pageReq); PagingUtility.calculateMetaData(metadata, trialsPage); @@ -356,34 +358,4 @@ private PublicationEntity convertToEntity(TrialNewRequestPublications pub) { return entity; } - - private String getSortByField(SortBy sortBy) { - String sortByStr = "id"; - if (sortBy != null) { - switch (sortBy) { - case STARTDATE: - sortByStr = "startDate"; - break; - case ENDDATE: - sortByStr = "endDate"; - break; - case TRIALNAME: - sortByStr = "trialName"; - break; - case PROGRAMDBID: - sortByStr = "program.id"; - break; - case PROGRAMNAME: - sortByStr = "program.name"; - break; - case TRIALDBID: - default: - sortByStr = "id"; - break; - } - } - - return sortByStr; - } - } diff --git a/src/main/java/org/brapi/test/BrAPITestServer/service/germ/GermplasmService.java b/src/main/java/org/brapi/test/BrAPITestServer/service/germ/GermplasmService.java index 2946fd58..13c45b7e 100644 --- a/src/main/java/org/brapi/test/BrAPITestServer/service/germ/GermplasmService.java +++ b/src/main/java/org/brapi/test/BrAPITestServer/service/germ/GermplasmService.java @@ -4,7 +4,14 @@ import java.util.*; import java.util.stream.Collectors; +import io.swagger.model.core.GermplasmListSearchRequest; +import io.swagger.model.core.ListDetails; +import io.swagger.model.core.ListItem; +import io.swagger.model.core.ListItemWithFullItem; import io.swagger.model.germ.*; +import io.swagger.model.sort.SortBy; +import io.swagger.model.sort.SortOrder; +import jakarta.persistence.Tuple; import jakarta.validation.Valid; import org.brapi.test.BrAPITestServer.exceptions.BrAPIServerDbIdNotFoundException; @@ -12,6 +19,8 @@ import org.brapi.test.BrAPITestServer.model.entity.BrAPIBaseEntity; import org.brapi.test.BrAPITestServer.model.entity.ExternalReferenceEntity; import org.brapi.test.BrAPITestServer.model.entity.core.CropEntity; +import org.brapi.test.BrAPITestServer.model.entity.core.ListItemEntity; +import org.brapi.test.BrAPITestServer.model.entity.core.ProgramEntity; import org.brapi.test.BrAPITestServer.model.entity.germ.*; import org.brapi.test.BrAPITestServer.model.entity.germ.GermplasmInstituteEntity.InstituteTypeEnum; import org.brapi.test.BrAPITestServer.model.entity.pheno.TaxonEntity; @@ -23,11 +32,11 @@ import org.brapi.test.BrAPITestServer.service.SearchQueryBuilder; import org.brapi.test.BrAPITestServer.service.UpdateUtility; import org.brapi.test.BrAPITestServer.service.core.CropService; +import org.brapi.test.BrAPITestServer.service.core.ProgramService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Page; -import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; @@ -44,21 +53,23 @@ public class GermplasmService { private final GermplasmDonorRepository donorRepository; private final BreedingMethodService breedingMethodService; private final CropService cropService; + private final ProgramService programService; @Autowired public GermplasmService(GermplasmRepository germplasmRepository, GermplasmDonorRepository donorRepository, - BreedingMethodService breedingMethodService, CropService cropService) { + BreedingMethodService breedingMethodService, CropService cropService, ProgramService programService) { this.germplasmRepository = germplasmRepository; this.donorRepository = donorRepository; this.breedingMethodService = breedingMethodService; this.cropService = cropService; + this.programService = programService; } public List findGermplasm(String germplasmPUI, String germplasmDbId, String germplasmName, String accessionNumber, String collection, String binomialName, String genus, String species, String trialDbId, String studyDbId, String synonym, String parentDbId, String progenyDbId, - String commonCropName, String programDbId, String externalReferenceId, String externalReferenceID, + String commonCropName, String programDbId, String programName, String externalReferenceId, String externalReferenceID, String externalReferenceSource, Metadata metadata) throws BrAPIServerException { @@ -93,6 +104,8 @@ public List findGermplasm(String germplasmPUI, String germplasmDbId, request.addCommonCropNamesItem(commonCropName); if (programDbId != null) request.addProgramDbIdsItem(programDbId); + if (programName != null) + request.addProgramNamesItem(programName); request.addExternalReferenceItem(externalReferenceId, externalReferenceID, externalReferenceSource); @@ -110,7 +123,7 @@ public List findGermplasm(@Valid GermplasmSearchRequest request, Meta return germplasms; } - public List findGermplasmWithoutPaging(@Valid GermplasmSearchRequest request) { + public List findGermplasmWithoutPaging(@Valid GermplasmSearchRequest request) throws BrAPIServerException { List entities = findGermplasmEntitiesWithoutPaging(request); return entities.stream().map(this::convertFromEntity).collect(Collectors.toList()); } @@ -123,6 +136,8 @@ public Page findGermplasmEntities(@Valid GermplasmSearchRequest // Since the built searchQuery contains a lazily loaded collection retrieved with a LEFT JOIN FETCH, // use findAllBySearchPaginatingWithFetches() + // TODO: As of BI-3082, the lazily loaded collection synonyms has been removed the initial search query. + // TODO: Because of this, we should be able to change this call to findAllBySearchAndPaginate, but this should be tracked as a separate effort. [BI-3084] Page germs = germplasmRepository.findAllBySearchPaginatingWithFetches(searchQuery, pageReq); // Hopefully this retains insertion order in the page? @@ -131,6 +146,8 @@ public Page findGermplasmEntities(@Valid GermplasmSearchRequest if (!germs.isEmpty()) { // If records were found, iterate through the rest of the lazily loaded collections of the GermplasmEntity // and LEFT JOIN FETCH all of them. + log.debug("Fetching synonyms"); + fetchSynonyms(ids, germs); log.debug("Fetching xrefs"); fetchXrefs(ids, germs); log.debug("fetching attributes"); @@ -151,42 +168,40 @@ public Page findGermplasmEntities(@Valid GermplasmSearchRequest return germs; } - public List findGermplasmEntitiesWithoutPaging(@Valid GermplasmSearchRequest request) { + // TODO: Investigate/consider removing this code. It is largely unused by DeltaBreed now, as paginating is the least memory exhaustive option. [BI-3020] + public List findGermplasmEntitiesWithoutPaging(@Valid GermplasmSearchRequest request) throws BrAPIServerException { SearchQueryBuilder searchQuery = buildGermplasmSearchQuery(request); List germs = germplasmRepository.findAllBySearch(searchQuery); if (!germs.isEmpty()) { - fetchRemainingGermCollectionsUsingQuery(searchQuery, germs); + fetchRemainingGermCollectionsUsingQuery(searchQuery, germs, request); } return germs; } - private SearchQueryBuilder buildGermplasmSearchQuery(GermplasmSearchRequest request) { + private SearchQueryBuilder buildGermplasmSearchQuery(GermplasmSearchRequest request) throws BrAPIServerException { SearchQueryBuilder searchQuery = new SearchQueryBuilder( GermplasmEntity.class); - searchQuery.leftJoinFetch("synonyms", "synonyms") - .leftJoinFetch("breedingMethod", "breedingMethod") + searchQuery.leftJoinFetch("breedingMethod", "breedingMethod") .leftJoinFetch("crop", "crop") .leftJoinFetch("pedigree", "pedigree") .leftJoinFetch("*pedigree.crossingProject", "crossingProject"); - if (request.getProgramDbIds() != null || request.getProgramNames() != null || request.getTrialDbIds() != null + if (request.getTrialDbIds() != null || request.getTrialNames() != null || request.getStudyDbIds() != null || request.getStudyNames() != null) { searchQuery = searchQuery.join("observationUnits", "obsunit") - .appendList(request.getProgramDbIds(), "*obsunit.program.id") - .appendList(request.getProgramNames(), "*obsunit.program.name") .appendList(request.getTrialDbIds(), "*obsunit.trial.id") .appendList(request.getTrialNames(), "*obsunit.trial.name") .appendList(request.getStudyDbIds(), "*obsunit.study.id") .appendList(request.getStudyNames(), "*obsunit.study.studyName"); } if (request.getSynonyms() != null) { - searchQuery = searchQuery.join("synonyms", "synonym").appendList(request.getSynonyms(), "*synonym.synonym"); + searchQuery = searchQuery.join("synonyms", "synonyms").appendList(request.getSynonyms(), "*synonyms.synonym"); } if (request.getInstituteCodes() != null) { - searchQuery = searchQuery.join("institutes", "institute").appendList(request.getSynonyms(), + searchQuery = searchQuery.join("institutes", "institute").appendList(request.getInstituteCodes(), "*institute.instituteCode"); } @@ -197,10 +212,13 @@ private SearchQueryBuilder buildGermplasmSearchQuery(GermplasmS .appendList(request.getGermplasmNames(), "germplasmName") .appendList(request.getGermplasmPUIs(), "germplasmPUI") .appendList(request.getParentDbIds(), "pedigree.parent1.germplasm.id") + .appendList(request.getProgramDbIds(), "program.id").appendList(request.getProgramNames(), "program.name") // .appendList(request.getProgenyDbIds(), "*progeny.germplasmDbId") .appendList(request.getGenus(), "genus").appendList(request.getSpecies(), "species") .appendNamesList(request.getBinomialNames(), "genus", "genus", "species") - .appendList(request.getFamilyCodes(), "familyCode"); + .appendList(request.getFamilyCodes(), "familyCode") + .filterBy(request.getFilterBy(), request.getEntityColInfoBySubmittedNameMap()) + .sortBy(request.getSortByElements(), request.getEntityColInfoBySubmittedNameMap()); return searchQuery; } @@ -209,6 +227,21 @@ private SearchQueryBuilder buildGermplasmSearchQuery(GermplasmS // TODO: Therefore no need to store a map and can just iterate through both at the same time O(n). // TODO: Revisit when sortBy is added to GermplasmSearchRequest and we can pass through a sortBy value. + + private void fetchSynonyms(List ids, Page germEntities) { + SearchQueryBuilder searchQuery = new SearchQueryBuilder<>(GermplasmEntity.class); + + searchQuery.leftJoinFetch("synonyms", "synonyms") + .appendIds(ids); + + List germsWithSynonyms = germplasmRepository.findAllBySearch(searchQuery); + + Map> synonymsByEntity = new HashMap<>(); + germsWithSynonyms.forEach(entity -> synonymsByEntity.put(entity.getId().toString(), entity.getSynonyms())); + + germEntities.forEach(entity -> entity.setSynonyms(synonymsByEntity.get(entity.getId().toString()))); + } + private void fetchXrefs(List ids, Page germEntities) { SearchQueryBuilder searchQuery = new SearchQueryBuilder<>(GermplasmEntity.class); @@ -326,17 +359,37 @@ private void fetchPedigreeEdges(List ids, Page germEntiti }); } - private void fetchRemainingGermCollectionsUsingQuery(SearchQueryBuilder searchQuery, List germEntities) { + private void fetchRemainingGermCollectionsUsingQuery(SearchQueryBuilder searchQuery, List germEntities, GermplasmSearchRequest request) { // Remove unused left join fetches from the base query - searchQuery.removeLeftJoinFetch("synonyms", "synonyms") - .removeLeftJoinFetch("breedingMethod", "breedingMethod") + searchQuery.removeLeftJoinFetch("breedingMethod", "breedingMethod") .removeLeftJoinFetch("crop", "crop") .removeLeftJoinFetch("pedigree", "pedigree") - .removeLeftJoinFetch("*pedigree.crossingProject", "crossingProject"); + .removeLeftJoinFetch("*pedigree.crossingProject", "crossingProject") + .resetSortClause(); + + // Fetch synonyms + log.debug("fetching synonyms"); + searchQuery.leftJoinFetch("synonyms", + "synonyms", true); + + List synonyms = germplasmRepository.findAllBySearch(searchQuery); + + Map> synonymsByEntity = new HashMap<>(); + synonyms.forEach(entity -> synonymsByEntity.put(entity.getId().toString(), entity.getSynonyms())); + + germEntities.forEach(entity -> entity.setSynonyms(synonymsByEntity.get(entity.getId().toString()))); + // Fetch xrefs log.debug("Fetching xrefs"); - searchQuery.leftJoinFetch("externalReferences", - "externalReferences"); + searchQuery.removeAndReplaceLeftJoinFetch("externalReferences", + "externalReferences", + "synonyms", + "synonyms"); + // Because the join was overwritten above, the original synonym join could have been removed with the replace. + // This extra join restores it so queries with join in the where clause can continue to work. + if (request.getSynonyms() != null) { + searchQuery.join("synonyms", "synonyms"); + } List xrefs = germplasmRepository.findAllBySearch(searchQuery); @@ -445,6 +498,19 @@ private void fetchRemainingGermCollectionsUsingQuery(SearchQueryBuilder> findGermplasmByList(ListDetails list, GermplasmListSearchRequest request, Metadata metadata) throws BrAPIServerException{ + + Page page = searchGermplasmByList(list, request, metadata); + + Page> listItems = page.map(this::convertFromEntity); + PagingUtility.calculateMetaData(metadata, page); + + return listItems.getContent(); + } + public Germplasm getGermplasm(String germplasmDbId) throws BrAPIServerException { return convertFromEntity(getGermplasmEntity(germplasmDbId, HttpStatus.NOT_FOUND)); } @@ -510,7 +576,24 @@ public List saveGermplasm(@Valid List body) thro .collect(Collectors.toList()); } - private Germplasm convertFromEntity(GermplasmEntity entity) { + private ListItemWithFullItem convertFromEntity(Tuple listItemAndGermplasmEntity) { + ListItemWithFullItem listItemWithFullItem = new ListItemWithFullItem<>(); + + ListItem listItem = new ListItem(); + + ListItemEntity listItemEntity = listItemAndGermplasmEntity.get(0, ListItemEntity.class); + + listItem.setListItemDbId(listItemEntity.getId().toString()); + listItem.setPosition(listItemEntity.getPosition()); + listItem.setItem(listItemEntity.getItem()); + + listItemWithFullItem.setListItem(listItem); + listItemWithFullItem.setItem(convertFromEntity(listItemAndGermplasmEntity.get(1, GermplasmEntity.class))); + + return listItemWithFullItem; + } + + public Germplasm convertFromEntity(GermplasmEntity entity) { Germplasm germ = new Germplasm(); UpdateUtility.convertFromEntity(entity, germ); @@ -528,6 +611,12 @@ private Germplasm convertFromEntity(GermplasmEntity entity) { germ.setCollection(entity.getCollection()); if (entity.getCrop() != null) germ.setCommonCropName(entity.getCrop().getCropName()); + + if (entity.getProgram() != null) { + germ.setProgramDbId(entity.getProgram().getId().toString()); + germ.setProgramName(entity.getProgram().getName()); + } + germ.setCountryOfOriginCode(entity.getCountryOfOriginCode()); germ.setDefaultDisplayName(entity.getDefaultDisplayName()); germ.setDocumentationURL(entity.getDocumentationURL()); @@ -581,6 +670,11 @@ private List createEntitiesInBatch(List bo .filter(Objects::nonNull) .collect(Collectors.toSet()); + Set programDbIds = body.stream() + .map(GermplasmNewRequest::getProgramDbId) + .filter(Objects::nonNull) + .collect(Collectors.toSet()); + Map foundBreedingMethodsById = breedingMethodService.findBreedingMethodsByIds(breedingMethodIds) .stream() @@ -590,6 +684,11 @@ private List createEntitiesInBatch(List bo .stream() .collect(Collectors.toMap(CropEntity::getCropName, e -> e)); + Map foundProgramsByDbId + = programService.findByIds(new ArrayList<>(programDbIds)) + .stream() + .collect(Collectors.toMap(ProgramEntity::getId, e -> e)); + for (GermplasmNewRequest request : body) { GermplasmEntity entity = new GermplasmEntity(); @@ -604,7 +703,7 @@ private List createEntitiesInBatch(List bo if (request.getBiologicalStatusOfAccessionCode() != null) entity.setBiologicalStatusOfAccessionCode(request.getBiologicalStatusOfAccessionCode()); if (request.getBreedingMethodDbId() != null) { - entity.setBreedingMethod(foundBreedingMethodsById.get(request.getBreedingMethodDbId())); + entity.setBreedingMethod(foundBreedingMethodsById.get(UUID.fromString(request.getBreedingMethodDbId()))); } if (request.getCollection() != null) entity.setCollection(request.getCollection()); @@ -661,6 +760,10 @@ private List createEntitiesInBatch(List bo updateSynonymEntities(request.getSynonyms(), entity); if (request.getTaxonIds() != null) updateTaxonEntities(request.getTaxonIds(), entity); + if (request.getProgramDbId() != null) { + ProgramEntity program = foundProgramsByDbId.get(UUID.fromString(request.getProgramDbId())); + entity.setProgram(program); + } toSave.add(entity); } @@ -738,6 +841,10 @@ private void updateEntity(GermplasmEntity entity, GermplasmNewRequest request) t updateSynonymEntities(request.getSynonyms(), entity); if (request.getTaxonIds() != null) updateTaxonEntities(request.getTaxonIds(), entity); + if (request.getProgramDbId() != null) { + ProgramEntity program = programService.getProgramEntity(request.getProgramDbId()); + entity.setProgram(program); + } } private void updateTaxonEntities(List taxonIds, GermplasmEntity entity) { @@ -1080,4 +1187,70 @@ private List getRedundantInstitutes( return dupInstitutes; } + public Page searchGermplasmByList(ListDetails list, GermplasmListSearchRequest searchRequest, Metadata metadata) throws BrAPIServerException { + + Pageable pageReq = PagingUtility.getPageRequest(metadata); + + List sortByElements = searchRequest.getSortByElements(); + + if (sortByElements == null || sortByElements.isEmpty()) { + // If there is no specified sort, sort by the position of the list. + SortBy defaultListItemSort = new SortBy("listItemPosition", SortOrder.ASC); + searchRequest.setSortBy(List.of(defaultListItemSort)); + } + + // This generates the search query which has any filters, sorting, and where's derived from the incoming search request. + SearchQueryBuilder searchQuery = buildGermplasmSearchQuery(searchRequest); + + searchQuery.modifySelect(List.of("listItem", "entity")); + + searchQuery.joinEntity(ListItemEntity.class, "listItem", " entity.germplasmName = listItem.item ") + .join("*listItem.list", "list") + .appendSingle(UUID.fromString(list.getListDbId()), "*list.id") + .appendEnum(list.getListType(), "*list.listType"); + + // At this point the search request should look something like: + // SELECT listItem, entity FROM GermplasmEntity entity + // JOIN ListItemEntity listItem ON entity.germplasmName = listItem.item + // JOIN listItem.list list + // (any other joins appearing came from buildGermplasmSearchQuery criteria) + // WHERE list.id IN (?) AND list.listType = ? AND (any other filters appearing came from buildGermplasmSearchQuery criteria) + // SORT BY (whatever is defined for listItemPosition in GermplasmListSearchRequest) ASC + // (If any other sorts appear here they were provided in the search request and were generated by buildGermplasmSearchQuery) + + Page listItemAndGerm = germplasmRepository.findAllBySearchAndPaginateMultipleEntitySelect(searchQuery, pageReq); + + Page germs = listItemAndGerm.map( + // Germplasm is the second column of the Tuple + row -> (GermplasmEntity) row.get(1) + ); + + List ids = germs.get().map(GermplasmEntity::getId).toList(); + + if (!germs.isEmpty()) { + // If records were found, iterate through the rest of the lazily loaded collections of the GermplasmEntity + // and LEFT JOIN FETCH all of them. + log.debug("Fetching synonyms"); + fetchSynonyms(ids, germs); + log.debug("Fetching xrefs"); + fetchXrefs(ids, germs); + log.debug("fetching attributes"); + fetchAttributes(ids, germs); + log.debug("fetching donors"); + fetchDonors(ids, germs); + log.debug("fetching origins"); + fetchOrigin(ids, germs); + log.debug("fetching institutes"); + fetchInstitutes(ids, germs); + log.debug("fetching taxons"); + fetchTaxons(ids, germs); + log.debug("fetching storage codes"); + fetchStorageCodes(ids, germs); + log.debug("fetching pedigree edges"); + fetchPedigreeEdges(ids, germs); + } + + return listItemAndGerm; + } + } diff --git a/src/main/resources/db/migration/U006_004__drop_germplasm_collation.sql b/src/main/resources/db/migration/U006_004__drop_germplasm_collation.sql new file mode 100644 index 00000000..f6d26961 --- /dev/null +++ b/src/main/resources/db/migration/U006_004__drop_germplasm_collation.sql @@ -0,0 +1,18 @@ +ALTER TABLE germplasm + DROP COLUMN created_by, + DROP COLUMN created_date, + DROP COLUMN breeding_method_sort, + DROP COLUMN female_parent_gid, + DROP COLUMN male_parent_gid; + +ALTER TABLE germplasm + ALTER COLUMN seed_source DROP DEFAULT, + ALTER COLUMN seed_source DROP NOT NULL, + ALTER COLUMN seed_source TYPE text COLLATE "default", + ALTER COLUMN default_display_name DROP DEFAULT, + ALTER COLUMN default_display_name DROP NOT NULL, + ALTER COLUMN default_display_name TYPE text COLLATE "default", + ALTER COLUMN accession_number DROP DEFAULT, + ALTER COLUMN accession_number DROP NOT NULL, + ALTER COLUMN accession_number TYPE text COLLATE "default"; + diff --git a/src/main/resources/db/migration/V006_001__migrate_parent_ou_ids.sql b/src/main/resources/db/migration/V006_001__migrate_parent_ou_ids.sql new file mode 100644 index 00000000..2166b229 --- /dev/null +++ b/src/main/resources/db/migration/V006_001__migrate_parent_ou_ids.sql @@ -0,0 +1,65 @@ +WITH + levels_and_parent_ou_bi_id AS ( +-- Find observation_unit_level codes that contain a key by checking for a space in the level code. +-- Only other level codes that can exist are block/rep. +-- Then extract the uuid from the level code, since program key is also contained there. + SELECT + id AS level_id, + substring(level_code FROM '^([^ ]+)') AS parent_bi_ou_id + FROM observation_unit_level + WHERE level_code LIKE '% %' + ), + -- This query should pick up external references with a unique external_reference_id and external_reference_source. + -- This is critical for this update as if there are any external references used that are not unique, + -- we could assign the wrong observation_unit_id. + exrefid_source_with_one_ou_connected AS ( + SELECT ex.external_reference_id, ex.external_reference_source, (array_agg(id))[1] AS exref_pk +FROM external_reference ex + JOIN observation_unit_external_references ouex ON ex.id = ouex.external_references_id +WHERE ex.external_reference_source = 'breedinginsight.org/observationunits' +GROUP BY ex.external_reference_id, ex.external_reference_source +HAVING count(*) = 1 + ), + ou_ids_matched_on_levels AS ( +-- Now match the bi-generated exref ou ids to ex refs ids, and keep observation_unit_level ids for matching in next part +SELECT + ou.id AS ou_id, + levels_and_parent_ou_bi_id.level_id +FROM observation_unit ou + JOIN observation_unit_external_references ouex ON ou.id = ouex.observation_unit_entity_id + JOIN exrefid_source_with_one_ou_connected ON exrefid_source_with_one_ou_connected.exref_pk = ouex.external_references_id + JOIN levels_and_parent_ou_bi_id ON exrefid_source_with_one_ou_connected.external_reference_id = levels_and_parent_ou_bi_id.parent_bi_ou_id + ) +UPDATE observation_unit_level +SET level_code = regexp_replace( + observation_unit_level.level_code, + '^[^ ]+', + mol.ou_id::text +) +FROM ou_ids_matched_on_levels mol +WHERE observation_unit_level.id = mol.level_id; + +-- Assertion to assure all expected top-level observation unit db ids were changed from external reference ids to observation unit db ids +DO $$ +DECLARE + top_level_observation_unit_level_count integer; + top_level_ouls_matched_to_ou_id integer; +BEGIN + SELECT COUNT(*) + INTO top_level_observation_unit_level_count + FROM observation_unit_level + WHERE level_code like '% %'; + + SELECT COUNT(*) + INTO top_level_ouls_matched_to_ou_id + FROM observation_unit_level oul + JOIN observation_unit ou on ou.id::text = substring(level_code FROM '^([^ ]+)') + WHERE level_code like '% %'; + + IF top_level_observation_unit_level_count <> top_level_ouls_matched_to_ou_id THEN + RAISE EXCEPTION + 'V006.001 After migration, expected all % observation_unit_level.code rows to match to observation_unit.id, but only % matched', + top_level_observation_unit_level_count, + top_level_ouls_matched_to_ou_id; + END IF; +END $$; \ No newline at end of file diff --git a/src/main/resources/db/migration/V006_002__migrate_sample_ou_ids.sql b/src/main/resources/db/migration/V006_002__migrate_sample_ou_ids.sql new file mode 100644 index 00000000..5ff206d3 --- /dev/null +++ b/src/main/resources/db/migration/V006_002__migrate_sample_ou_ids.sql @@ -0,0 +1,61 @@ +WITH + samples_and_bi_ou_ids AS ( +-- Look for samples that have obsUnitIDs and keep ids in hand for next query + SELECT + id as sample_id, + additional_info ->> 'obsUnitID' AS bi_ou_id + FROM sample + WHERE additional_info ? 'obsUnitID' + ), + exrefid_source_with_one_ou_connected AS ( + SELECT ex.external_reference_id, ex.external_reference_source, (array_agg(id))[1] AS exref_pk + FROM external_reference ex + JOIN observation_unit_external_references ouex ON ex.id = ouex.external_references_id + WHERE ex.external_reference_source = 'breedinginsight.org/observationunits' + GROUP BY ex.external_reference_id, ex.external_reference_source + HAVING COUNT(*) = 1 + ), + ou_ids_matched_on_samples AS ( +-- Now match the bi-generated exref ou ids to ex refs ids, and keep samples ids for matching in update + SELECT + ou.id AS ou_id, + samples_and_bi_ou_ids.sample_id + FROM observation_unit ou + JOIN observation_unit_external_references ouex ON ou.id = ouex.observation_unit_entity_id + JOIN exrefid_source_with_one_ou_connected on exrefid_source_with_one_ou_connected.exref_pk = ouex.external_references_id + JOIN samples_and_bi_ou_ids ON exrefid_source_with_one_ou_connected.external_reference_id = samples_and_bi_ou_ids.bi_ou_id + ) +UPDATE sample +SET additional_info = jsonb_set( + additional_info, + '{obsUnitID}', + to_jsonb(mos.ou_id) +) +FROM ou_ids_matched_on_samples mos +WHERE id = mos.sample_id; + +-- Assertion to ensure all samples with ou in additional info now relate to observation unit db id +DO $$ + DECLARE + samples_with_ou_count integer; + samples_with_ous_matched_to_ou_count integer; + BEGIN + SELECT COUNT(*) + INTO samples_with_ou_count + FROM sample + WHERE additional_info ? 'obsUnitID'; + + SELECT COUNT(*) + INTO samples_with_ous_matched_to_ou_count + FROM sample s + JOIN observation_unit ou on ou.id::text = s.additional_info ->> 'obsUnitID' + WHERE s.additional_info ? 'obsUnitID'; + + IF samples_with_ou_count <> samples_with_ous_matched_to_ou_count THEN + RAISE EXCEPTION + 'V006.002 After migration, expected all % sample.additional_info->>obsUnitID rows to match to observation_unit.id, but only % matched', + samples_with_ou_count, + samples_with_ous_matched_to_ou_count; + END IF; + END +$$; \ No newline at end of file diff --git a/src/main/resources/db/migration/V006_003__add_program_id_to_germplasm_and_migrate.sql b/src/main/resources/db/migration/V006_003__add_program_id_to_germplasm_and_migrate.sql new file mode 100644 index 00000000..eb13b87a --- /dev/null +++ b/src/main/resources/db/migration/V006_003__add_program_id_to_germplasm_and_migrate.sql @@ -0,0 +1,40 @@ +ALTER TABLE germplasm +ADD COLUMN program_id UUID; + +ALTER TABLE germplasm +ADD CONSTRAINT germplasm_program_fk + FOREIGN KEY (program_id) + REFERENCES public.program(id); + +CREATE INDEX germplasm_program_idx ON germplasm (program_id, id); + +UPDATE germplasm set program_id = pquery.program_id +FROM ( + SELECT g.id AS germplasm_id, p.id AS program_id + FROM germplasm g + JOIN germplasm_external_references gex ON g.id = gex.germplasm_entity_id + JOIN external_reference ex ON ex.id = gex.external_references_id + JOIN external_reference ex2 ON ex2.external_reference_id = ex.external_reference_id + JOIN program_external_references pex ON pex.external_references_id = ex2.id + JOIN program p ON p.id = pex.program_entity_id + WHERE ex.external_reference_source = 'breedinginsight.org/programs' AND ex2.external_reference_source = 'breedinginsight.org') pquery +WHERE id = pquery.germplasm_id; + +-- Assertion to ensure all germplasm are now associated with a program +DO $$ + DECLARE + germs_without_program_count integer; + + BEGIN + SELECT COUNT(*) + INTO germs_without_program_count + FROM germplasm g + WHERE g.program_id IS NULL; + + IF germs_without_program_count <> 0 THEN + RAISE EXCEPTION + 'V006.003 After migration, expected all germplasm rows to have program_id set, but there are % rows with program_id not set', + germs_without_program_count; + END IF; + END +$$; \ No newline at end of file diff --git a/src/main/resources/db/migration/V006_004__collate_germplasm_columns.sql b/src/main/resources/db/migration/V006_004__collate_germplasm_columns.sql new file mode 100644 index 00000000..a3b0acea --- /dev/null +++ b/src/main/resources/db/migration/V006_004__collate_germplasm_columns.sql @@ -0,0 +1,57 @@ +CREATE COLLATION IF NOT EXISTS natural_sort ( + provider = icu, + locale = 'en-u-kn-true' + ); + +ALTER TABLE germplasm ALTER COLUMN accession_number SET DEFAULT ''; +UPDATE germplasm SET accession_number = '' WHERE accession_number IS NULL; +ALTER TABLE germplasm ALTER COLUMN accession_number SET NOT NULL; +ALTER TABLE germplasm ALTER COLUMN accession_number TYPE text COLLATE natural_sort; + +ALTER TABLE germplasm ALTER COLUMN default_display_name SET DEFAULT ''; +UPDATE germplasm SET default_display_name = '' WHERE default_display_name IS NULL; +ALTER TABLE germplasm ALTER COLUMN default_display_name SET NOT NULL; +ALTER TABLE germplasm ALTER COLUMN default_display_name TYPE text COLLATE natural_sort; + +ALTER TABLE germplasm ALTER COLUMN seed_source SET DEFAULT ''; +UPDATE germplasm SET seed_source = '' WHERE seed_source IS NULL; +ALTER TABLE germplasm ALTER COLUMN seed_source SET NOT NULL; +ALTER TABLE germplasm ALTER COLUMN seed_source TYPE text COLLATE natural_sort; + +ALTER TABLE germplasm + ADD COLUMN + male_parent_gid text NOT NULL COLLATE natural_sort + GENERATED ALWAYS AS (COALESCE(additional_info #>> '{maleParentGid}', '')) STORED ; + +ALTER TABLE germplasm + ADD COLUMN + female_parent_gid text NOT NULL COLLATE natural_sort + GENERATED ALWAYS AS (COALESCE(additional_info #>> '{femaleParentGid}', '')) STORED ; + +ALTER TABLE germplasm + ADD COLUMN + breeding_method_sort text NOT NULL COLLATE natural_sort + GENERATED ALWAYS AS (COALESCE(additional_info #>> '{breedingMethod}', '')) STORED ; + +ALTER TABLE germplasm + ADD COLUMN created_date TIMESTAMP NOT NULL + GENERATED ALWAYS AS ( + CASE + WHEN additional_info #>> '{createdDate}' IS NULL + THEN TIMESTAMP '1970-01-01 00:00:00' + ELSE + make_timestamp( + substring(additional_info #>> '{createdDate}' from 7 for 4)::int, -- year + substring(additional_info #>> '{createdDate}' from 4 for 2)::int, -- month + substring(additional_info #>> '{createdDate}' from 1 for 2)::int, -- day + substring(additional_info #>> '{createdDate}' from 12 for 2)::int, -- hour + substring(additional_info #>> '{createdDate}' from 15 for 2)::int, -- minute + substring(additional_info #>> '{createdDate}' from 18 for 2)::int -- second + ) + END + ) STORED; + +ALTER TABLE germplasm + ADD COLUMN + created_by text NOT NULL COLLATE natural_sort + GENERATED ALWAYS AS (COALESCE(additional_info #>> '{createdBy,userName}', '')) STORED ;