Class DatasetsWebService

java.lang.Object
ubic.gemma.rest.DatasetsWebService
@Service @Path("/datasets") public class DatasetsWebService extends Object
RESTful interface for datasets.
Author:
tesarst

  • Field Details

  • Constructor Details

    • DatasetsWebService

      public DatasetsWebService()

  • Method Details

    • getDatasets

      @GZIP @GET @Produces("application/json") public DatasetsWebService.QueriedAndFilteredAndInferredAndPaginatedResponseDataObject<DatasetsWebService.ExpressionExperimentWithSearchResultValueObject> getDatasets(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filterArg, @QueryParam("offset") @DefaultValue("0") OffsetArg offsetArg, @QueryParam("limit") @DefaultValue("20") LimitArg limitArg, @QueryParam("sort") SortArg<ExpressionExperiment> sortArg)

    • searchDatasets

      @Deprecated @GET @Path("/search") @Produces("application/json") public ResponseDataObject<List<DatasetsWebService.DatasetSearchHitValueObject>> searchDatasets(@QueryParam("query") QueryArg query, @QueryParam("limit") @DefaultValue("20") LimitArg limit)
      Deprecated.
      redundant with GET /datasets?query=... (the paginated catalogue runs the same search), which every known client uses instead — no caller of this endpoint was found across gemma-ui, gemma-curation-agents, or gemma.R. Scheduled for removal in the 2.10 release.
      Typeahead-style search for datasets. Wraps the global SearchService filtered to ExpressionExperiment and projects each hit to a thin DatasetsWebService.DatasetSearchHitValueObject. Intended for the curation-UI browser import dialog (see GEMMA_UI_ENDPOINT_GAP.md §3i).

    • getNumberOfDatasets

      @GET @Path("/count") @Produces("application/json") public ResponseDataObject<Long> getNumberOfDatasets(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter)

    • getNumberOfSamples

      @GET @Path("/samples/count") @Produces("application/json") public ResponseDataObject<Long> getNumberOfSamples(@QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter)

    • getDatasetsPlatformsUsageStatistics

      @GZIP @GET @Path("/platforms") @Produces("application/json") public DatasetsWebService.QueriedAndFilteredAndInferredAndLimitedResponseDataObject<DatasetsWebService.ArrayDesignWithUsageStatisticsValueObject> getDatasetsPlatformsUsageStatistics(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("limit") @DefaultValue("50") LimitArg limit)

    • refreshDatasetsPlatforms

      @GET @Path("/platforms/refresh") @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Produces("application/json") public jakarta.ws.rs.core.Response refreshDatasetsPlatforms(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("limit") @DefaultValue("50") LimitArg limit)

    • getDatasetsCategoriesUsageStatistics

      @GET @Path("/categories") @Produces("application/json") public DatasetsWebService.QueriedAndFilteredAndInferredAndLimitedResponseDataObject<DatasetsWebService.CategoryWithUsageStatisticsValueObject> getDatasetsCategoriesUsageStatistics(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("limit") @DefaultValue("20") LimitArg limit, @QueryParam("excludedCategories") StringArrayArg excludedCategoryUris, @QueryParam("excludeFreeTextCategories") @DefaultValue("false") Boolean excludeFreeTextCategories, @QueryParam("excludedTerms") StringArrayArg excludedTermUris, @QueryParam("excludeFreeTextTerms") @DefaultValue("false") Boolean excludeFreeTextTerms, @QueryParam("excludeUncategorizedTerms") @DefaultValue("false") Boolean excludeUncategorizedTerms, @QueryParam("retainMentionedTerms") @DefaultValue("false") Boolean retainMentionedTerms)

    • getDatasetsAnnotationsUsageStatistics

      @GET @GZIP @Path("/annotations") @Produces("application/json") public DatasetsWebService.QueriedAndFilteredAndInferredAndLimitedResponseDataObject<DatasetsWebService.AnnotationWithUsageStatisticsValueObject> getDatasetsAnnotationsUsageStatistics(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("exclude") ExcludeArg<DatasetsWebService.AnnotationWithUsageStatisticsValueObject> exclude, @QueryParam("limit") LimitArg limitArg, @QueryParam("minFrequency") Integer minFrequency, @QueryParam("category") String category, @QueryParam("excludedCategories") StringArrayArg excludedCategoryUris, @QueryParam("excludeFreeTextCategories") @DefaultValue("false") Boolean excludeFreeTextCategories, @QueryParam("excludedTerms") StringArrayArg excludedTermUris, @QueryParam("excludeFreeTextTerms") @DefaultValue("false") Boolean excludeFreeTextTerms, @QueryParam("excludeUncategorizedTerms") @DefaultValue("false") Boolean excludeUncategorizedTerms, @QueryParam("retainMentionedTerms") @DefaultValue("false") Boolean retainMentionedTerms, @QueryParam("includePredicates") @DefaultValue("false") Boolean includePredicates, @QueryParam("includeObjects") @DefaultValue("false") Boolean includeObjects)

    • getNumberOfAnnotations

      @GET @Path("/annotations/count") @Produces("application/json") public ResponseDataObject<Long> getNumberOfAnnotations(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("category") String category, @QueryParam("minFrequency") @DefaultValue("1") Integer minFrequency, @QueryParam("excludeFreeText") @DefaultValue("false") Boolean excludeFreeText)

    • refreshDatasetsAnnotations

      @GET @Path("/annotations/refresh") @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Produces("application/json") public jakarta.ws.rs.core.Response refreshDatasetsAnnotations(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("exclude") ExcludeArg<DatasetsWebService.AnnotationWithUsageStatisticsValueObject> exclude, @QueryParam("limit") LimitArg limitArg, @QueryParam("minFrequency") Integer minFrequency, @QueryParam("category") String category, @QueryParam("excludedCategories") StringArrayArg excludedCategoryUris, @QueryParam("excludeFreeTextCategories") @DefaultValue("false") Boolean excludeFreeTextCategories, @QueryParam("excludedTerms") StringArrayArg excludedTermUris, @QueryParam("excludeFreeTextTerms") @DefaultValue("false") Boolean excludeFreeTextTerms, @QueryParam("excludeUncategorizedTerms") @DefaultValue("false") Boolean excludeUncategorizedTerms, @QueryParam("retainMentionedTerms") @DefaultValue("false") Boolean retainMentionedTerms, @QueryParam("includePredicates") @DefaultValue("false") Boolean includePredicates, @QueryParam("includeObjects") @DefaultValue("false") Boolean includeObjects)

    • getDatasetsTaxaUsageStatistics

      @GET @Path("/taxa") @Produces("application/json") public DatasetsWebService.QueriedAndFilteredAndInferredResponseDataObject<DatasetsWebService.TaxonWithUsageStatisticsValueObject> getDatasetsTaxaUsageStatistics(@QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filterArg)

    • getDatasetsByIds

      @GET @Path("/{dataset}") @Produces("application/json") public Object getDatasetsByIds(@PathParam("dataset") DatasetArrayArg datasetsArg, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("offset") @DefaultValue("0") OffsetArg offset, @QueryParam("limit") @DefaultValue("20") LimitArg limit, @QueryParam("sort") @DefaultValue("+id") SortArg<ExpressionExperiment> sort, @QueryParam("cursor") CursorArg cursorArg)
      Retrieves all datasets matching the given identifiers.
      Parameters:
      datasetsArg - a list of identifiers, separated by commas (','). Identifiers can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient.

      Only datasets that user has access to will be available.

      Do not combine different identifiers in one query.

    • getBlacklistedDatasets

      @GET @Path("/blacklisted") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public Object getBlacklistedDatasets(@QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filterArg, @QueryParam("sort") @DefaultValue("+id") SortArg<ExpressionExperiment> sortArg, @QueryParam("offset") @DefaultValue("0") OffsetArg offset, @QueryParam("limit") @DefaultValue("20") LimitArg limit, @QueryParam("cursor") CursorArg cursorArg)
      Browse blacklisted datasets.

    • getDatasetPlatforms

      @GET @Path("/{dataset}/platforms") @Produces("application/json") public ResponseDataObject<List<ArrayDesignValueObject>> getDatasetPlatforms(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("original") @DefaultValue("false") Boolean original)
      Retrieves platforms for the given dataset.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • getDatasetSamples

      @GET @GZIP @Path("/{dataset}/samples") @Produces("application/json") public Object getDatasetSamples(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> quantitationTypeArg, @QueryParam("useProcessedQuantitationType") boolean useProcessedQuantitationType, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("limit") LimitArg limitArg, @QueryParam("exclude") ExcludeArg<BioAssayValueObject> excludeArg, @QueryParam("includePredictedOutliers") @DefaultValue("false") boolean includePredictedOutliers)
      Retrieves the samples for the given dataset.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • markDatasetSampleOutlier

      @PUT @Path("/{dataset}/samples/{bioAssayId}/outlier") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<BioAssayValueObject> markDatasetSampleOutlier(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("bioAssayId") Long bioAssayId, @Nullable DatasetsWebService.SampleOutlierRequest body)
      Mark (or unmark) a BioAssay as a sample outlier.

      Curation-UI workflow-step endpoint: the experiment-page "flag/unflag outlier" buttons call this. Flagging sets the assay's processed-data values to missing via OutlierFlaggingService.markAsMissing(Collection); the inverse reverts that. The endpoint validates that the supplied bioAssay belongs to the path-derived dataset before mutating, returning 400 otherwise.

    • batchMarkSampleOutliers

      @POST @Path("/{dataset}/samples/outliers") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.BatchOutlierResponse> batchMarkSampleOutliers(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.BatchOutlierRequest body)
      Batch outlier mark / unmark. Pairs with GET /sample-correlation — the UI builds up mark/unmark deltas as the curator clicks samples, then sends a single request to persist the change. Delta semantics (not declarative replacement) so a filtered UI view can't accidentally unflag samples the user couldn't see.

    • markFactorValueNeedsAttention

      @POST @Path("/{dataset}/factor-values/{factorValueId}/needs-attention") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_USER')") public jakarta.ws.rs.core.Response markFactorValueNeedsAttention(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("factorValueId") Long factorValueId, @Nullable DatasetsWebService.FactorValueNeedsAttentionRequest body)
      Open a "needs attention" ticket against a factor value.

      Replaces the legacy gemma-web ExperimentalDesignController.markFactorValuesAsNeedsAttention AJAX call. Routes through FactorValueNeedsAttentionService, which opens a TicketType.GENERIC ticket targeting both the factor value and its owning EE.

    • clearFactorValueNeedsAttention

      @DELETE @Path("/{dataset}/factor-values/{factorValueId}/needs-attention") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_USER')") public jakarta.ws.rs.core.Response clearFactorValueNeedsAttention(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("factorValueId") Long factorValueId, @QueryParam("note") @Nullable String note)
      Resolve every open needs-attention ticket on a factor value.

    • getDatasetAllPublications

      @GET @Path("/{dataset}/publications") @Produces("application/json") public ResponseDataObject<List<DatasetPublicationValueObject>> getDatasetAllPublications(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("includeRejected") @DefaultValue("false") Boolean includeRejected)

    • getDatasetSourceMetadata

      @GET @GZIP @Path("/{dataset}/sourceMetadata") @Produces("application/json") public ResponseDataObject<com.fasterxml.jackson.databind.JsonNode> getDatasetSourceMetadata(@PathParam("dataset") DatasetArg<?> datasetArg)

    • updateDatasetPublications

      @PUT @Path("/{dataset}/publications") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<List<DatasetPublicationValueObject>> updateDatasetPublications(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.PublicationsUpdateRequest body)

    • getDatasetTickets

      @GET @Path("/{dataset}/tickets") @Produces("application/json") public Object getDatasetTickets(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("limit") @DefaultValue("20") LimitArg limitArg)

    • getDatasetTicketsBulk

      @POST @Path("/tickets") @Consumes("application/json") @Produces("application/json") @PreAuthorize("isAuthenticated()") public ResponseDataObject<Map<Long, List<TicketSummaryForTargetValueObject>>> getDatasetTicketsBulk(@Nullable DatasetsWebService.DatasetTicketsBulkRequest body)

    • getDatasetGroups

      @GET @Path("/{dataset}/groups") @Produces("application/json") public ResponseDataObject<?> getDatasetGroups(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("includeSummaries") @DefaultValue("false") boolean includeSummaries, @QueryParam("include_summaries") @DefaultValue("false") boolean includeSummariesLegacy)
      Groups that have ANY permission (read or admin) on the given dataset (gap §3c of GEMMA_UI_ENDPOINT_GAP.md). When includeSummaries=true, each entry includes the group's lightweight summary (name, description, memberCount); otherwise only the group names are returned.

    • getDatasetAuditEvents

      @GET @GZIP @Path("/{dataset}/auditEvents") @Produces("application/json") public Object getDatasetAuditEvents(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("limit") @Nullable LimitArg limitArg, @QueryParam("compact") @DefaultValue("false") boolean compact, @QueryParam("excludeEmpty") @DefaultValue("false") boolean excludeEmpty)

    • submitDatasetAnnotationSet

      @POST @Path("/{dataset}/annotation-sets") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response submitDatasetAnnotationSet(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable AnnotationSetsWebService.AnnotationSetRequest body)

    • snapshotDatasetCuration

      @POST @Path("/{dataset}/annotation-sets/snapshot") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response snapshotDatasetCuration(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("createdBy") @Nullable String createdBy)

    • restoreDatasetCurationFromSnapshot

      @POST @Path("/{dataset}/annotation-sets/{setId}/restore") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public ResponseDataObject<DatasetsWebService.CurationCommitReport> restoreDatasetCurationFromSnapshot(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("setId") Long setId, @QueryParam("dryRun") @DefaultValue("false") Boolean dryRun, @QueryParam("force") @DefaultValue("false") Boolean force, @QueryParam("onBehalfOf") @Nullable String onBehalfOf)

    • listDatasetAnnotationSets

      @GET @GZIP @Path("/{dataset}/annotation-sets") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response listDatasetAnnotationSets(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("role") @Nullable String role, @QueryParam("source") @Nullable String source, @QueryParam("createdBy") @Nullable String createdBy, @QueryParam("shape") @Nullable String shape)

    • recordCurationDecision

      @POST @Path("/{dataset}/curation/decisions") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response recordCurationDecision(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @Nullable DatasetsWebService.CurationDecisionRequest body)
      Record a curator's standing ruling that a change must NOT be made -- or, rarely, that one may be.

    • getCurationDecisions

      @GET @Path("/{dataset}/curation/decisions") @Produces("application/json") @PreAuthorize("isAuthenticated()") public jakarta.ws.rs.core.Response getCurationDecisions(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("history") @DefaultValue("false") boolean history)
      The standing refusals on a dataset, or the whole decision log.

    • getCurationLock

      @GET @Path("/{dataset}/curation/lock") @Produces("application/json") @PreAuthorize("isAuthenticated()") public jakarta.ws.rs.core.Response getCurationLock(@PathParam("dataset") DatasetArg<?> datasetArg)
      🛑 This route deliberately serves the BARE object, not the {"data": …} envelope the rest of the service uses. Do not "fix" the inconsistency.

      The curation UI's api/client.ts unwraps only when a data key is present and nothing but envelope keys sits beside it, so the bare body passes through intact and getCurationLock types it as CurationLock. Wrapping it would make the client read locked off the envelope, get undefined — falsy — and conclude that nobody holds the lock. It would not error. It would invite a second curator into an experiment someone else is editing, which is the failure this lock exists to prevent, and no test here would catch it because the response is still valid JSON.

      The inconsistency was raised by cab on 2026-09-09 after their cleanup read data.locked, got {} and skipped a release, leaving a dataset locked for its lease. That was a client assuming an envelope it had not checked, not a shape problem; cab now accepts both. uib established the direction of the danger and asked that it not change without their client landing first.

      ⇒ If this ever does gain the envelope: uib's client goes first, this second, and the two are separate deploys. Not a change to make quietly alongside something else.

    • acquireCurationLock

      @POST @Path("/{dataset}/curation/lock") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response acquireCurationLock(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("steal") @DefaultValue("false") Boolean steal, @QueryParam("ttlMinutes") @DefaultValue("30") Integer ttlMinutes, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @QueryParam("runId") @Nullable String runId, @QueryParam("agentName") @Nullable String agentName)

    • releaseCurationLock

      @DELETE @Path("/{dataset}/curation/lock") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response releaseCurationLock(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf)

    • getCurationLocks

      @GET @Path("/curation/locks") @Produces("application/json") @PreAuthorize("isAuthenticated()") public ResponseDataObject<Map<Long, DatasetsWebService.CurationLockResponse>> getCurationLocks(@QueryParam("datasets") DatasetArrayArg datasets)

    • getCurationLocksBulk

      @POST @Path("/curation/locks/query") @Consumes("application/json") @Produces("application/json") @PreAuthorize("isAuthenticated()") public ResponseDataObject<Map<Long, DatasetsWebService.CurationLockResponse>> getCurationLocksBulk(@Nullable DatasetsWebService.CurationLockBulkRequest body)

    • acquireCurationLocks

      @POST @Path("/curation/locks") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public ResponseDataObject<Map<Long, DatasetsWebService.CurationLockBulkResult>> acquireCurationLocks(@QueryParam("steal") @DefaultValue("false") Boolean steal, @QueryParam("ttlMinutes") @DefaultValue("30") Integer ttlMinutes, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @QueryParam("runId") @Nullable String runId, @QueryParam("agentName") @Nullable String agentName, @Nullable DatasetsWebService.CurationLockBulkRequest body)

    • releaseCurationLocks

      @POST @Path("/curation/locks/release") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public ResponseDataObject<Map<Long,Boolean>> releaseCurationLocks(@QueryParam("onBehalfOf") @Nullable String onBehalfOf, @Nullable DatasetsWebService.CurationLockBulkRequest body)

    • signDatasetCuration

      @POST @Path("/{dataset}/curation/sign") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public ResponseDataObject<DatasetsWebService.CurationCommitReport> signDatasetCuration(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @QueryParam("dryRun") @DefaultValue("false") Boolean dryRun, @QueryParam("keepLock") @DefaultValue("false") Boolean keepLock, @Nullable DatasetsWebService.CurationDocument body)

    • getDatasetDraftAnnotationSet

      @GET @Path("/{dataset}/annotation-sets/draft") @Produces("application/json") @PreAuthorize("isAuthenticated()") public jakarta.ws.rs.core.Response getDatasetDraftAnnotationSet(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf)

    • upsertDatasetDraftAnnotationSet

      @PUT @Path("/{dataset}/annotation-sets/draft") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN') or hasAuthority('GROUP_AGENT')") public jakarta.ws.rs.core.Response upsertDatasetDraftAnnotationSet(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @Nullable AnnotationSetsWebService.UpsertDraftRequest body)

    • getDatasetCurationDetails

      @GET @Path("/{dataset}/curationDetails") @Produces("application/json") public ResponseDataObject<CurationDetailsValueObject> getDatasetCurationDetails(@PathParam("dataset") DatasetArg<?> datasetArg)

    • updateDatasetCurationDetails

      @PUT @Path("/{dataset}/curationDetails") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Deprecated public ResponseDataObject<CurationDetailsValueObject> updateDatasetCurationDetails(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.CurationDetailsUpdateRequest body)
      Deprecated.
      per Decision 1 of AUDIT_AS_WORKFLOW_RECCE.md the troubled / needsAttention flips are now backed by TicketService: a troubled=true flip opens a TicketType.QUALITY_REVIEW ticket, troubled=false resolves the matching open ticket(s), and analogously for needsAttention (mapped to TicketType.GENERIC on open). Clients should migrate to POST /tickets + PUT /tickets/{id} on TicketsWebService. The endpoint is retained for back-compat while the UI moves over. The curationNote field is still routed through CurationNoteUpdateEvent pending the note-to-ticket-comment migration (see CURATION_DETAILS_RETIREMENT.md).

    • renameDatasetShortName

      @PUT @Path("/{dataset}/short-name") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.RenameDatasetResponse> renameDatasetShortName(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.RenameDatasetRequest body)

    • updateDatasetBasics

      @PATCH @Path("/{dataset}") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<DatasetsWebService.DatasetBasicsResponse> updateDatasetBasics(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.DatasetBasicsUpdateRequest body)

    • commitCuration

      @PUT @Path("/{dataset}/curation") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<DatasetsWebService.CurationCommitReport> commitCuration(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("force") @DefaultValue("false") Boolean force, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @Nullable DatasetsWebService.CurationDocument body)

    • preflightCuration

      @POST @Path("/{dataset}/curation/preflight") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<DatasetsWebService.CurationCommitReport> preflightCuration(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("onBehalfOf") @Nullable String onBehalfOf, @Nullable DatasetsWebService.CurationDocument body)

    • updateDatasetPermissions

      @PUT @Path("/{dataset}/permissions") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> updateDatasetPermissions(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.PermissionsUpdateRequest body)

    • getDatasetPermissions

      @GET @Path("/{dataset}/permissions") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> getDatasetPermissions(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieve the current sharing state of a dataset.

      Curation-UI helper: the experiment-page sharing widget needs to read the current public/shared state without performing an update. Same response shape as updateDatasetPermissions(DatasetArg, DatasetsWebService.PermissionsUpdateRequest).

    • makeDatasetPublic

      @POST @Path("/{dataset}/makePublic") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> makeDatasetPublic(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI workflow-step endpoint: raw ACL flip to make a dataset publicly readable. Distinct from POST /publish (which is a curator-state-machine transition that ALSO calls this under the hood). Idempotent — re-running on an already-public dataset is a no-op.

    • makeDatasetPrivate

      @POST @Path("/{dataset}/makePrivate") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> makeDatasetPrivate(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI workflow-step endpoint: raw ACL flip to make a dataset private. Idempotent.

    • publishDataset

      @POST @Path("/{dataset}/publish") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> publishDataset(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("reviewer") @Nullable String reviewer)
      Curation-UI workflow-step endpoint: curator-state-machine transition that publishes a dataset under a named reviewer. Distinct from POST /makePublic: this endpoint ALSO records the reviewer as a DatasetPublishedEvent audit event (with the reviewer encoded in the note), and is idempotent on already-published datasets (audit-only emission then).

    • getDatasetVisibility

      @GET @Path("/{dataset}/visibility") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<DatasetsWebService.DatasetPermissionsValueObject> getDatasetVisibility(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI compatibility alias for getDatasetPermissions(DatasetArg). The UI's dataset-page sharing widget calls GET /datasets/{id}/visibility; the canonical gemma-rest endpoint lives at /datasets/{id}/permissions. Hidden from the OpenAPI spec to avoid duplicating the canonical entry.

    • getDatasetPipelineStatusAlias

      @GET @Path("/{dataset}/pipeline-status") @Produces("application/json") public ResponseDataObject<PipelineStatusValueObject> getDatasetPipelineStatusAlias(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI compatibility alias for getDatasetPipelineStatus(DatasetArg): the UI uses the flatter, hyphenated path /datasets/{id}/pipeline-status; the canonical handler lives at /pipelineStatus.

    • getDatasetPipelineStatus

      @GET @Path("/{dataset}/pipelineStatus") @Produces("application/json") public ResponseDataObject<PipelineStatusValueObject> getDatasetPipelineStatus(@PathParam("dataset") DatasetArg<?> datasetArg)

    • getDatasetsPipelineStatus

      @GET @Path("/pipelineStatus") @Produces("application/json") public ResponseDataObject<List<PipelineStatusValueObject>> getDatasetsPipelineStatus(@QueryParam("datasets") DatasetArrayArg datasets)
      Bulk sibling of getDatasetPipelineStatus(DatasetArg).

      🛑 The path is the literal /datasets/pipelineStatus with the ids in a query parameter, NOT /datasets/{datasets}/pipelineStatus: the latter is the same JAX-RS template as the single-dataset route — a path parameter's NAME does not distinguish it — so declaring it would be an ambiguous mapping rather than a second route.

    • getStaleDatasets

      @GET @Path("/staleSteps") @Produces("application/json") public PaginatedResponseDataObject<DatasetsWebService.StaleDatasetValueObject> getStaleDatasets(@QueryParam("offset") @DefaultValue("0") OffsetArg offset, @QueryParam("limit") @DefaultValue("20") LimitArg limit)
      The datasets that owe pipeline work: every dataset with at least one stale step, and which steps those are.

      🛑 A literal path segment sharing a level with /{dataset}, like /blacklisted — JAX-RS prefers the literal, so /datasets/staleSteps does not resolve as a dataset named "staleSteps".

    • getDatasetPipelineStatusBulk

      @POST @Path("/pipeline-status") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<Map<Long, PipelineStatusValueObject>> getDatasetPipelineStatusBulk(@Nullable DatasetsWebService.PipelineStatusBulkRequest body)

    • getDatasetGeeq

      @GET @Path("/{dataset}/geeq") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<GeeqValueObject> getDatasetGeeq(@PathParam("dataset") DatasetArg<?> datasetArg)

    • getDatasetGeeqPublic

      @GET @Path("/{dataset}/geeq/public") @Produces("application/json") public ResponseDataObject<GeeqValueObject> getDatasetGeeqPublic(@PathParam("dataset") DatasetArg<?> datasetArg)
      Public sibling of getDatasetGeeq(DatasetArg): returns the per-factor GEEQ breakdown without exposing the admin-only detected/manual override scores or the free-text otherIssues curator field, which live on GeeqAdminValueObject. Drives the GEEQ-badge popover in the browser UI for anonymous and non-admin users.

      Served by GeeqValueObject directly. This used to return a parallel PublicGeeqValueObject, written on the belief that the per-factor getters on GeeqValueObject were JSON-suppressed; they were not — each backing field carries an explicit @JsonProperty that Jackson keeps over the ignore on the parallel getter. The two VOs serialized identical 25-key payloads, so the duplicate was retired.

    • recomputeDatasetGeeq

      @PUT @Path("/{dataset}/geeq") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<GeeqValueObject> recomputeDatasetGeeq(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("mode") @DefaultValue("all") GeeqService.ScoreMode mode)

    • recomputeDatasetGeeqViaPost

      @POST @Path("/{dataset}/geeq/recompute") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<GeeqValueObject> recomputeDatasetGeeqViaPost(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.GeeqRecomputeRequest body)
      Alias for recomputeDatasetGeeq(DatasetArg, GeeqService.ScoreMode) that exposes the GEEQ recompute under POST /datasets/{id}/geeq/recompute with a JSON body.

      Curation-UI compatibility shim: the curation-UI workflow-step "recompute GEEQ" button posts to this path. Behaviour is identical to PUT /datasets/{id}/geeq — both delegate to the same handler. The mode defaults to all when the body is omitted. See CURATION_UI_HANDOFF_INVENTORY.md.

    • recomputeDatasetGeeqViaPostAlias

      @POST @Path("/{dataset}/geeq/recalculate") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<GeeqValueObject> recomputeDatasetGeeqViaPostAlias(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.GeeqRecomputeRequest body)
      Curation-UI compatibility alias for recomputeDatasetGeeqViaPost(DatasetArg, DatasetsWebService.GeeqRecomputeRequest): UI calls POST /datasets/{id}/geeq/recalculate with the same body shape.

    • importDataset

      @POST @Path("/import") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response importDataset(@Nullable DatasetsWebService.DatasetImportRequest body)
      Curation-UI workflow-step endpoint: kick off an async GEO (or ArrayExpress) accession load. The actual loader runs inside ExpressionExperimentLoadTaskCommand; this handler submits the command to the TaskRunningService and returns a 202 with a Location header pointing at the polling endpoint.

    • runDatasetPreprocess

      @POST @Path("/{dataset}/tasks/preprocess") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetPreprocess(@PathParam("dataset") DatasetArg<?> datasetArg)

    • runDatasetDiagnostics

      @POST @Path("/{dataset}/tasks/diagnostics") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetDiagnostics(@PathParam("dataset") DatasetArg<?> datasetArg)

    • runDatasetSvd

      @POST @Path("/{dataset}/tasks/svd") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetSvd(@PathParam("dataset") DatasetArg<?> datasetArg)

    • runDatasetBatchInformationFetch

      @POST @Path("/{dataset}/tasks/batchInfo") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetBatchInformationFetch(@PathParam("dataset") DatasetArg<?> datasetArg)

    • runDatasetGeeq

      @POST @Path("/{dataset}/tasks/geeq") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetGeeq(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("mode") @DefaultValue("all") GeeqService.ScoreMode mode)

    • runDatasetSwitchPlatform

      @POST @Path("/{dataset}/tasks/switch-platform") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetSwitchPlatform(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.PlatformSwitchRequest body)

    • runDatasetPreprocessAlias

      @POST @Path("/{dataset}/preprocess") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetPreprocessAlias(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI compatibility alias for runDatasetPreprocess(DatasetArg): UI calls POST /datasets/{id}/preprocess.

    • runDatasetDiagnosticsAlias

      @POST @Path("/{dataset}/preprocess/diagnostics") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetDiagnosticsAlias(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI compatibility alias for runDatasetDiagnostics(DatasetArg): UI calls POST /datasets/{id}/preprocess/diagnostics.

    • runDatasetBatchInformationFetchAlias

      @POST @Path("/{dataset}/batchInformation/fetch") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetBatchInformationFetchAlias(@PathParam("dataset") DatasetArg<?> datasetArg)
      Curation-UI compatibility alias for runDatasetBatchInformationFetch(DatasetArg): UI calls POST /datasets/{id}/batchInformation/fetch.

    • runDatasetDifferentialAnalysis

      @POST @Path("/{dataset}/tasks/differential") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetDifferentialAnalysis(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.DifferentialAnalysisRunRequest body)

    • runDatasetDifferentialAnalysisAlias

      @POST @Path("/{dataset}/analyses/differential") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response runDatasetDifferentialAnalysisAlias(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.DifferentialAnalysisRunRequest body)
      Alias for runDatasetDifferentialAnalysis(DatasetArg, DifferentialAnalysisRunRequest) that exposes the DEA dispatch under /datasets/{id}/analyses/differential.

      Curation-UI compatibility shim: the curation-UI dispatch hook (apps/curation/.../workflow.ts:165) calls POST /datasets/{id}/analyses/differential; the canonical gemma-rest endpoint lives at /tasks/differential. Both paths delegate to the same handler so the UI's "dispatch DEA" button works without modification. See CURATION_UI_HANDOFF_INVENTORY.md.

    • redoDatasetDifferentialAnalysis

      @POST @Path("/{dataset}/tasks/redo/{analysisId}") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response redoDatasetDifferentialAnalysis(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("analysisId") Long analysisId)

    • removeDatasetDifferentialAnalysis

      @DELETE @Path("/{dataset}/tasks/differential/{analysisId}") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response removeDatasetDifferentialAnalysis(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("analysisId") Long analysisId)

    • redoDatasetDifferentialAnalysisAlias

      @POST @Path("/{dataset}/analyses/differential/{analysisId}/redo") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response redoDatasetDifferentialAnalysisAlias(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("analysisId") Long analysisId)
      Curation-UI compatibility alias for redoDatasetDifferentialAnalysis(DatasetArg, Long): UI calls POST /datasets/{id}/analyses/differential/{aid}/redo; the canonical handler lives at /tasks/redo/{analysisId}.

    • removeDatasetDifferentialAnalysisAlias

      @DELETE @Path("/{dataset}/analyses/differential/{analysisId}") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response removeDatasetDifferentialAnalysisAlias(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("analysisId") Long analysisId)
      Curation-UI compatibility alias for removeDatasetDifferentialAnalysis(DatasetArg, Long): UI calls DELETE /datasets/{id}/analyses/differential/{aid}.

    • deleteDatasetRawData

      @DELETE @Path("/{dataset}/data/raw") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response deleteDatasetRawData(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> quantitationTypeArg, @QueryParam("confirm") @DefaultValue("false") boolean confirm)
      Delete the raw expression data vectors for a dataset (port of deleteRawData CLI).

      Synchronous DB delete. Requires the destructive-intent guard confirm=true; without it the request is rejected as a 400 so an accidental call (mistyped URL, stale browser tab) cannot wipe vectors. The quantitationType query param selects which raw QT to delete; when omitted the dataset's preferred raw QT is used.

    • deleteDatasetProcessedData

      @DELETE @Path("/{dataset}/data/processed") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public jakarta.ws.rs.core.Response deleteDatasetProcessedData(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("confirm") @DefaultValue("false") boolean confirm)
      Delete the processed expression data vectors for a dataset (port of deleteProcessedData CLI).

      Synchronous DB delete. Requires the destructive-intent guard confirm=true; without it the request is rejected as a 400 so an accidental call cannot wipe vectors.

    • getDatasetDifferentialExpressionAnalyses

      @GET @Path("/{dataset}/analyses/differential") @Produces("application/json") public ResponseDataObject<List<DifferentialExpressionAnalysisValueObject>> getDatasetDifferentialExpressionAnalyses(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("offset") @DefaultValue("0") OffsetArg offsetArg, @QueryParam("limit") @DefaultValue("20") LimitArg limitArg, @QueryParam("includeAssays") @DefaultValue("false") boolean includeAssays)
      Retrieves the differential analysis results for the given dataset.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • getDatasetDifferentialExpressionAnalysisResultSets

      @GET @Path("/{dataset}/analyses/differential/resultSets") public jakarta.ws.rs.core.Response getDatasetDifferentialExpressionAnalysisResultSets(@PathParam("dataset") DatasetArg<?> datasetArg, @Context jakarta.ws.rs.core.UriInfo uriInfo)
      Retrieves the result sets of all the differential expression analyses of a dataset.

      This is actually performing a 302 Found redirection to point the HTTP client to the corresponding result sets endpoint.

      See Also:

    • getDatasetsDifferentialExpressionAnalysisResultsForGene

      @GET @GZIP @Path("/analyses/differential/results/genes/{gene}") @Produces({"application/json","text/tab-separated-values; charset=UTF-8; q=0.9"}) public Object getDatasetsDifferentialExpressionAnalysisResultsForGene(@PathParam("gene") GeneArg<?> geneArg, @QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("offset") OffsetArg offsetArg, @QueryParam("limit") LimitArg limitArg, @QueryParam("threshold") @DefaultValue("1.0") Double threshold, @Context jakarta.ws.rs.core.HttpHeaders headers)
      Obtain differential expression analysis results for a given gene.

    • getDatasetsDifferentialExpressionAnalysisResultsForGeneInTaxon

      @GET @GZIP @Path("/analyses/differential/results/taxa/{taxon}/genes/{gene}") @Produces({"application/json","text/tab-separated-values; charset=UTF-8"}) public Object getDatasetsDifferentialExpressionAnalysisResultsForGeneInTaxon(@PathParam("taxon") TaxonArg<?> taxonArg, @PathParam("gene") GeneArg<?> geneArg, @QueryParam("query") QueryArg query, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filter, @QueryParam("offset") OffsetArg offsetArg, @QueryParam("limit") LimitArg limitArg, @QueryParam("threshold") @DefaultValue("1.0") Double threshold, @Context jakarta.ws.rs.core.HttpHeaders headers)
      Obtain differential expression analysis results for a given gene in a given taxon.

    • getDatasetAnnotations

      @GET @GZIP @Path("/{dataset}/annotations") @Produces("application/json") public ResponseDataObject<Set<AnnotationValueObject>> getDatasetAnnotations(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("includeFreeText") @DefaultValue("true") Boolean includeFreeText)
      Retrieves the annotations for the given dataset.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • updateDatasetAnnotations

      @PUT @Path("/{dataset}/annotations") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<Set<AnnotationValueObject>> updateDatasetAnnotations(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable DatasetsWebService.AnnotationsUpdateRequest body)

    • addDatasetAnnotationTag

      @POST @Path("/{dataset}/annotations") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN')") public jakarta.ws.rs.core.Response addDatasetAnnotationTag(@PathParam("dataset") DatasetArg<?> datasetArg, @Nullable AnnotationsWebService.AnnotationDto body, @QueryParam("annotationSetId") @Nullable Long annotationSetId)

    • removeDatasetAnnotationTag

      @DELETE @Path("/{dataset}/annotations/{annotationId}") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR') or hasAuthority('GROUP_ADMIN')") public jakarta.ws.rs.core.Response removeDatasetAnnotationTag(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("annotationId") Long annotationId)

    • getSampleCharacteristics

      @GET @Path("/{dataset}/samples/{bioAssayId}/characteristics") @Produces("application/json") public ResponseDataObject<Set<AnnotationValueObject>> getSampleCharacteristics(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("bioAssayId") Long bioAssayId)

    • updateSampleCharacteristics

      @PUT @Path("/{dataset}/samples/{bioAssayId}/characteristics") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<Set<AnnotationValueObject>> updateSampleCharacteristics(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("bioAssayId") Long bioAssayId, @Nullable DatasetsWebService.AnnotationsUpdateRequest body)

    • addSampleCharacteristic

      @POST @Path("/{dataset}/samples/{bioAssayId}/characteristics") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<AnnotationValueObject> addSampleCharacteristic(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("bioAssayId") Long bioAssayId, @Nullable DatasetsWebService.AnnotationTagInput body)

    • removeSampleCharacteristic

      @DELETE @Path("/{dataset}/samples/{bioAssayId}/characteristics/{characteristicId}") @Produces("application/json") public ResponseDataObject<AnnotationValueObject> removeSampleCharacteristic(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("bioAssayId") Long bioAssayId, @PathParam("characteristicId") Long characteristicId)

    • getDatasetQuantitationTypes

      @GET @Path("/{dataset}/quantitationTypes") @Produces("application/json") public ResponseDataObject<Set<QuantitationTypeValueObject>> getDatasetQuantitationTypes(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieve all available quantitation types for a dataset.

    • setDatasetQuantitationTypePreferred

      @PATCH @Path("/{dataset}/quantitationTypes/{qtId}/preferred") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<QuantitationTypeValueObject> setDatasetQuantitationTypePreferred(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("qtId") Long qtId, @Nullable DatasetsWebService.QuantitationTypePreferredRequest body)
      Mark a QuantitationType as the preferred one (within its vector-type bucket) for the given dataset.

      Curation-UI workflow-step endpoint: the experiment-page "set preferred QT" button calls this. The ExpressionExperimentService.updateQuantitationType(ExpressionExperiment, QuantitationType, QuantitationType) handler takes care of the "unmark every other QT of the same vector type" book-keeping and emits the appropriate PreferredDataChangedEvent. Body may be omitted (defaults to preferred=true) or supplied as {"preferred": false} to clear the flag.

    • patchDatasetQuantitationType

      @PATCH @Path("/{dataset}/quantitationTypes/{qtId}") @Consumes("application/json") @Produces("application/json") @PreAuthorize("hasAuthority('GROUP_CURATOR')") public ResponseDataObject<QuantitationTypeValueObject> patchDatasetQuantitationType(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("qtId") Long qtId, @Nullable DatasetsWebService.QuantitationTypePatchRequest body)
      Body-driven PATCH dispatcher for a quantitation type. Curation-UI calls PATCH /datasets/{id}/quantitationTypes/{qtId} with {"isPreferred": true} instead of routing through the /preferred suffix; this handler dispatches based on which fields are present.

    • getDatasetSingleCellDimension

      @GZIP @GET @Produces({"application/json","text/tab-separated-values; charset=UTF-8"}) @Path("/{dataset}/singleCellDimension") public Object getDatasetSingleCellDimension(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> qtArg, @QueryParam("exclude") ExcludeArg<SingleCellDimensionValueObject> excludeArg, @QueryParam("useBioAssayId") @DefaultValue("false") Boolean useBioAssayIds, @Context jakarta.ws.rs.core.HttpHeaders headers)
      Retrieve the single-cell dimension for a given quantitation type.

    • getDatasetCellTypeAssignment

      @GZIP @GET @Produces({"application/json","text/tab-separated-values; charset=UTF-8"}) @Path("/{dataset}/cellTypeAssignment") public Object getDatasetCellTypeAssignment(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> qtArg, @QueryParam("cellTypeAssignment") String ctaName, @QueryParam("protocol") String protocolName, @QueryParam("exclude") ExcludeArg<CellTypeAssignmentValueObject> excludeArg, @QueryParam("useBioAssayId") @DefaultValue("false") Boolean useBioAssayId, @Context jakarta.ws.rs.core.HttpHeaders headers)

    • getDatasetCellLevelCharacteristics

      @GZIP @GET @Produces({"application/json","text/tab-separated-values; charset=UTF-8"}) @Path("/{dataset}/cellLevelCharacteristics") public Object getDatasetCellLevelCharacteristics(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> qtArg, @Context jakarta.ws.rs.core.HttpHeaders headers)

    • getDatasetExpression

      @GZIP(mediaTypes="text/tab-separated-values; charset=UTF-8", alreadyCompressed=true) @GET @Path("/{dataset}/data") @Produces("text/tab-separated-values; charset=UTF-8") public jakarta.ws.rs.core.Response getDatasetExpression(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("filter") @DefaultValue("false") Boolean filterData, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force)
      Retrieves the data for the given dataset.

      The returned TSV format contains the following columns:

      • Probe
      • Sequence
      • GeneSymbol (optional)
      • GeneName (optional)
      • GemmaId (optional)
      • NCBIid (optional)
      followed by one column per sample.

      Note: Additional gene information is only available if the corresponding platform's annotations has been dumped on-disk.

      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.
      filterData - return filtered the expression data.

    • getDatasetProcessedExpression

      @GZIP(mediaTypes="text/tab-separated-values; charset=UTF-8", alreadyCompressed=true) @GET @Path("/{dataset}/data/processed") @Produces("text/tab-separated-values; charset=UTF-8") public jakarta.ws.rs.core.Response getDatasetProcessedExpression(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("filter") @DefaultValue("false") Boolean filtered, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force)
      Retrieve processed expression data.

      The payload is transparently compressed via a Content-Encoding header and streamed to avoid dumping the whole payload in memory.

    • getDatasetRawExpression

      @GZIP(mediaTypes="text/tab-separated-values; charset=UTF-8", alreadyCompressed=true) @GET @Path("/{dataset}/data/raw") @Produces("text/tab-separated-values; charset=UTF-8") public jakarta.ws.rs.core.Response getDatasetRawExpression(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> quantitationTypeArg, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force)
      Retrieve raw expression data.

      The payload is transparently compressed via a Content-Encoding header and streamed to avoid dumping the whole payload in memory.

    • getDatasetDiffExAnalysisArchive

      @GET @Path("/{dataset}/data/dea") @Produces("application/octet-stream") public jakarta.ws.rs.core.Response getDatasetDiffExAnalysisArchive(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("analysisId") Long analysisId, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force)
      Retrieve the differential-expression analysis archive for a dataset.

      Builds (or, on cache hit, locates) the ZIP archive containing the analysis result + per-result-set contrast files for a single differential-expression analysis on this dataset, and sendfile-s the cached file directly.

      The archive is generated lazily on first access by ExpressionDataFileService.writeOrLocateDiffExAnalysisArchiveFile(DifferentialExpressionAnalysis, boolean); subsequent accesses skip the rebuild.

      If the dataset has more than one differential-expression analysis, the caller must disambiguate by passing analysisId; otherwise the response is 409 Conflict.

    • getDatasetSingleCellExpression

      @GZIP(mediaTypes="text/tab-separated-values; charset=UTF-8", alreadyCompressed=true) @GET @Path("/{dataset}/data/singleCell") @Produces({"application/vnd.10xgenomics.mex","text/tab-separated-values; charset=UTF-8;q=0.9"}) public jakarta.ws.rs.core.Response getDatasetSingleCellExpression(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> quantitationTypeArg, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force, @Context jakarta.ws.rs.core.HttpHeaders headers)

    • getDatasetDesignJson

      @GET @GZIP @Path("/{dataset}/design") @Produces("application/json") public ResponseDataObject<ExperimentalDesignValueObject> getDatasetDesignJson(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieves the structured experimental design for the given dataset as JSON.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234).

    • previewDatasetDesignChange

      @POST @Path("/{dataset}/designPreflight") @Consumes("application/json") @Produces("application/json") public ResponseDataObject<DesignPreflightReport> previewDatasetDesignChange(@PathParam("dataset") DatasetArg<?> datasetArg, ExperimentalDesignValueObject proposed)
      Dry-run preflight for a proposed design replacement.

      Accepts the same JSON shape that GET /datasets/{id}/design returns (ExperimentalDesignValueObject), with id fields treated as identity claims (existing entity) or null (new entity), and returns a DesignPreflightReport describing validation errors and the impact a real PUT would have.

      The preflight never mutates state. POST is used (not GET) because the response depends on a non-trivial request body.

    • replaceDatasetDesign

      @PUT @Path("/{dataset}/design") @Consumes("application/json") @Produces("application/json") public jakarta.ws.rs.core.Response replaceDatasetDesign(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("force") @DefaultValue("false") Boolean force, @QueryParam("agentProposalId") @Nullable Long agentProposalId, ExperimentalDesignValueObject proposed)
      Apply a proposed ExperimentalDesignValueObject as the experiment's new design.

      The same validation pass performed by POST /datasets/{id}/designPreflight is re-run server-side. If blockers are present, returns 400 with a DesignPreflightReport payload — fix the body and retry. If the change carries consequences needing consent — it would delete differential-expression analyses, or leave a subset anchored on factor values that no longer exist — and force=false, returns 409 with the report; admins may re-issue with ?force=true. The 409 body is the report itself, so the client can show the curator exactly which analyses and which subsets they are agreeing to. On success, returns 200 with the freshly-rebuilt design.

    • getDatasetDesign

      @GZIP(mediaTypes="text/tab-separated-values; charset=UTF-8", alreadyCompressed=true) @GET @Path("/{dataset}/design") @Produces("text/tab-separated-values; charset=UTF-8;qs=0.9") public jakarta.ws.rs.core.Response getDatasetDesign(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("quantitationType") QuantitationTypeArg<?> quantitationTypeArg, @QueryParam("useProcessedQuantitationType") @DefaultValue("false") Boolean useProcessedQuantitationType, @QueryParam("download") @DefaultValue("false") Boolean download, @QueryParam("force") @DefaultValue("false") Boolean force)
      Retrieves the design for the given dataset.

      Two response media types are supported on this path, selected via the Accept header:

      • application/json (default) — a structured ExperimentalDesignValueObject with factors, factor values (statements with stable IDs), and biomaterial-to-factor-value assignments. The JSON variant ignores the quantitationType/ useProcessedQuantitationType parameters.
      • text/tab-separated-values; charset=UTF-8 — the design matrix as TSV, served only when requested explicitly via Accept.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • getDatasetMetadataFiles

      @GET @Path("/{dataset}/metadata") @Produces("application/json") public ResponseDataObject<List<DatasetsWebService.DatasetMetadataFileValueObject>> getDatasetMetadataFiles(@PathParam("dataset") DatasetArg<?> datasetArg)
      List the preprocessing-metadata files available for a dataset.

      Entries reflect ExpressionExperimentMetaFileType instances whose underlying file exists on disk for the given experiment. The MULTIQC_REPORT alias is suppressed (it duplicates RNASEQ_PIPELINE_REPORT with the same id).

    • getDatasetMetadataFile

      @GET @Path("/{dataset}/metadata/{type}") @Produces("application/octet-stream") public jakarta.ws.rs.core.Response getDatasetMetadataFile(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("type") String typeArg, @QueryParam("download") @DefaultValue("false") Boolean download)
      Stream a single preprocessing-metadata file by type for a dataset.

      Returns 404 if the file is absent on disk or the type is a directory with no contents. Successful responses use the file's native MIME type from ExpressionExperimentMetaFileType.getContentType().

    • getDatasetHasBatchInformation

      @GET @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Path("/{dataset}/hasbatch") @Produces("application/json") public ResponseDataObject<Boolean> getDatasetHasBatchInformation(@PathParam("dataset") DatasetArg<?> datasetArg)
      Indicate if the experiment has batch information.

      This does not imply that the batch information is usable. This will be true even if there is only one batch. It does not reflect the presence or absence of a batch effect.

    • getDatasetBatchInformation

      @GET @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Produces("application/json") @Path("/{dataset}/batchInformation") public ResponseDataObject<DatasetsWebService.BatchInformationValueObject> getDatasetBatchInformation(@PathParam("dataset") DatasetArg<?> datasetArg)

    • getDatasetMeanVariance

      @GET @GZIP @Path("/{dataset}/mean-variance") @Produces("application/json") public ResponseDataObject<DatasetsWebService.MeanVarianceValueObject> getDatasetMeanVariance(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieves the per-probe mean / variance pre-computed by MeanVarianceService.

      404 when ExpressionExperiment.getMeanVarianceRelation() is null (i.e. the mean-variance step hasn't been run for the dataset). Backs the curation-UI Diagnostics tab's mean-variance scatter.

    • getDatasetSampleCorrelation

      @GET @GZIP @Path("/{dataset}/sample-correlation") @Produces("application/json") public ResponseDataObject<DatasetsWebService.SampleCorrelationMatrixValueObject> getDatasetSampleCorrelation(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("matrix") @DefaultValue("best") DatasetsWebService.CorrelationMatrixChoice which)
      Retrieves the sample-sample correlation matrix plus both outlier classifications (curator-flagged + algorithmic), unmasked.

      The UI applies its own masking interactively so the curator can see the effect of including / excluding outliers on the correlation distribution. Two outlier sets accompany the matrix:

    • getDatasetQcMetrics

      @GET @GZIP @Path("/{dataset}/qc-metrics") @Produces("application/json") public ResponseDataObject<DatasetsWebService.SequencingQcMetricsValueObject> getDatasetQcMetrics(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieves the per-sample sequencing QC metrics for a dataset — read depth, mapping rate, duplication and the rest of the RNA-Seq pipeline's MultiQC general statistics — keyed by bioAssay id.

      These are independent of expression similarity, which is the outlier detector's only input, so they are the second piece of evidence when judging a low-correlation sample. Nothing here feeds OutlierDetectionService; the endpoint is read-only evidence.

      See Also:

    • getDatasetSvd

      @GET @Path("/{dataset}/svd") @Produces("application/json") public ResponseDataObject<DatasetsWebService.SimpleSVDValueObject> getDatasetSvd(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieves the design for the given dataset.
      Parameters:
      datasetArg - can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

    • getDatasetSvdLoadings

      @GET @Path("/{dataset}/svd/loadings") @Produces("application/json") public ResponseDataObject<DatasetsWebService.PcLoadingsValueObject> getDatasetSvdLoadings(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("pc") Integer pc, @QueryParam("top") @DefaultValue("50") Integer top, @QueryParam("direction") @DefaultValue("both") DatasetsWebService.PcLoadingDirection direction)
      Retrieve the top-N probe loadings on a chosen principal component, plus the bioAssay scores on that PC. Backs the curation-UI Diagnostics tab's "click-PC → loaded-genes popup" flow.

      Uses SVDService.getTopLoadedVectors(ExpressionExperiment, int, int) to fetch the stored ProbeLoading rows for the component (one DB hit; no expression-matrix recompute). bioAssay scores come from the SVDResult's vMatrix column for the PC. Gene refs are resolved from the gene IDs the fetched vectors already carry, in one batched load, and ship in the same HeatmapDataValueObject.GeneRef shape heatmap-data rows use. Returns 404 if the dataset has no SVD analysis, 400 if pc or top are out of range.

    • getDatasetsExpressionLevelsForGene

      @GET @Path("/expressions/genes/{gene}") @Produces("application/json") public Object getDatasetsExpressionLevelsForGene(@PathParam("gene") GeneArg<?> geneArg, @QueryParam("query") QueryArg queryArg, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filterArg, @QueryParam("offset") @DefaultValue("0") OffsetArg offsetArg, @QueryParam("limit") @DefaultValue("20") LimitArg limitArg, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("precise") @DefaultValue("false") Boolean precise)
      Retrieve the expression levels of a given gene across all datasets.

    • getDatasetsExpressionLevelsForGeneInTaxon

      @GET @Path("/expressions/taxa/{taxon}/genes/{gene}") @Produces("application/json") public Object getDatasetsExpressionLevelsForGeneInTaxon(@PathParam("taxon") TaxonArg<?> taxonArg, @PathParam("gene") GeneArg<?> geneArg, @QueryParam("query") QueryArg queryArg, @QueryParam("filter") @DefaultValue("") FilterArg<ExpressionExperiment> filterArg, @QueryParam("offset") @DefaultValue("0") OffsetArg offsetArg, @QueryParam("limit") @DefaultValue("20") LimitArg limitArg, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("precise") @DefaultValue("false") Boolean precise)
      Retrieve the expression levels of a given gene and taxon across all datasets.

    • getDatasetsExpressionLevelsForGenesInTaxon

      @GET @Path("/{datasets}/expressions/taxa/{taxon}/genes/{genes}") @Produces("application/json") public ResponseDataObject<List<ExperimentExpressionLevelsValueObject>> getDatasetsExpressionLevelsForGenesInTaxon(@PathParam("datasets") DatasetArrayArg datasets, @PathParam("taxon") TaxonArg<?> taxonArg, @PathParam("genes") GeneArrayArg genes, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("precise") @DefaultValue("false") Boolean precise)
      Retrieves the expression levels of given genes on given datasets.
      Parameters:
      datasets - a list of dataset identifiers separated by commas (','). The identifiers can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

      You can combine various identifiers in one query, but an invalid identifier will cause the call to yield an error.

      taxonArg - a taxon to retrieve gene identifiers from
      genes - a list of gene identifiers, separated by commas (','). Identifiers can be one of NCBI ID, Ensembl ID or official symbol. NCBI ID is the most efficient (and guaranteed to be unique) identifier. Official symbol will return a random homologue. Use one of the IDs to specify the correct taxon - if the gene taxon does not match the taxon of the given datasets, expression levels for that gene will be missing from the response.

      You can combine various identifiers in one query, but an invalid identifier will cause the call to yield an error.

      keepNonSpecific - whether to keep elements that are mapped to multiple genes.
      consolidate - whether genes with multiple elements should consolidate the information. The options are:
      • pickmax: only return the vector that has the highest expression (mean over all its bioAssays)
      • pickvar: only return the vector with highest variance of expression across its bioAssays
      • average: create a new vector that will average the bioAssay values from all vectors

    • getDatasetsExpressionLevelsForGenes

      @GET @Path("/{datasets}/expressions/genes/{genes}") @Produces("application/json") public ResponseDataObject<List<ExperimentExpressionLevelsValueObject>> getDatasetsExpressionLevelsForGenes(@PathParam("datasets") DatasetArrayArg datasets, @PathParam("genes") GeneArrayArg genes, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("precise") @DefaultValue("false") Boolean precise)

    • getDatasetsExpressionPca

      @GET @Path("/{datasets}/expressions/pca") @Produces("application/json") public ResponseDataObject<List<ExperimentExpressionLevelsValueObject>> getDatasetsExpressionPca(@PathParam("datasets") DatasetArrayArg datasets, @QueryParam("component") @DefaultValue("1") Integer component, @QueryParam("limit") @DefaultValue("100") LimitArg limit, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("precise") @DefaultValue("false") Boolean precise)
      Retrieves the expression levels of genes highly expressed in the given component on given datasets.
      Parameters:
      datasets - a list of dataset identifiers separated by commas (','). The identifiers can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

      You can combine various identifiers in one query, but an invalid identifier will cause the call to yield an error.

      component - the pca component to limit the results to.
      limit - maximum amount of returned gene-probe expression level pairs.
      keepNonSpecific - whether to keep elements that are mapped to multiple genes.
      consolidate - whether genes with multiple elements should consolidate the information. The options are:
      • pickmax: only return the vector that has the highest expression (mean over all its bioAssays)
      • pickvar: only return the vector with highest variance of expression across its bioAssays
      • average: create a new vector that will average the bioAssay values from all vectors

    • getDatasetsDifferentialExpression

      @GET @Path("/{datasets}/expressions/differential") @Produces("application/json") public ResponseDataObject<List<ExperimentExpressionLevelsValueObject>> getDatasetsDifferentialExpression(@PathParam("datasets") DatasetArrayArg datasets, @QueryParam("diffExSet") Long diffExSet, @QueryParam("threshold") @DefaultValue("1.0") Double threshold, @QueryParam("limit") @DefaultValue("100") LimitArg limit, @QueryParam("keepNonSpecific") @DefaultValue("false") Boolean keepNonSpecific, @QueryParam("consolidate") ExpLevelConsolidationArg consolidate, @QueryParam("precise") @DefaultValue("false") Boolean precise)
      Retrieves the expression levels of genes highly expressed in the given component on given datasets.
      Parameters:
      datasets - a list of dataset identifiers separated by commas (','). The identifiers can either be the ExpressionExperiment ID or its short name (e.g. GSE1234). Retrieval by ID is more efficient. Only datasets that user has access to will be available.

      You can combine various identifiers in one query, but an invalid identifier will cause the call to yield an error.

      diffExSet - the ID of the differential expression set to retrieve the data from.
      threshold - the FDR threshold that the differential expression has to meet to be included in the response.
      limit - maximum amount of returned gene-probe expression level pairs.
      keepNonSpecific - whether to keep elements that are mapped to multiple genes.
      consolidate - whether genes with multiple elements should consolidate the information. The options are:
      • pickmax: only return the vector that has the highest expression (mean over all its bioAssays)
      • pickvar: only return the vector with highest variance of expression across its bioAssays
      • average: create a new vector that will average the bioAssay values from all vectors

    • refreshDataset

      @GET @PreAuthorize("hasAuthority('GROUP_CURATOR')") @Path("/{dataset}/refresh") @Produces("application/json") public jakarta.ws.rs.core.Response refreshDataset(@PathParam("dataset") DatasetArg<?> datasetArg, @QueryParam("refreshVectors") @DefaultValue("false") Boolean refreshVectors, @QueryParam("refreshReports") @DefaultValue("false") Boolean refreshReports)
      Retrieve a "refreshed" dataset.

      This has the main side effect of refreshing the second-level cache with the contents of the database.

    • getDatasetSubSetGroups

      @GET @Path("/{dataset}/subSetGroups") @Produces("application/json") public ResponseDataObject<List<DatasetsWebService.ExpressionExperimentSubSetGroupValueObject>> getDatasetSubSetGroups(@PathParam("dataset") DatasetArg<?> datasetArg)
      Retrieve all the "groups" of subsets of a dataset.

      Each group of subsets is logically organized by a BioAssayDimension that holds its assays. We don't expose that aspect however, and simply use the ID of the BAD as ID of the group.

    • getDatasetSubSetGroup

      @GET @Path("/{dataset}/subSetGroups/{subSetGroup}") @Produces("application/json") public ResponseDataObject<DatasetsWebService.ExpressionExperimentSubSetGroupValueObject> getDatasetSubSetGroup(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("subSetGroup") Long bioAssayDimensionId, @QueryParam("includePredictedOutliers") @DefaultValue("false") boolean includePredictedOutliers)

    • getDatasetSubSets

      @GET @Path("/{dataset}/subSets") @Produces("application/json") public ResponseDataObject<List<DatasetsWebService.ExpressionExperimentSubSetWithGroupsValueObject>> getDatasetSubSets(@PathParam("dataset") DatasetArg<?> datasetArg)

    • getDatasetSubSetById

      @GET @Path("/{dataset}/subSets/{subSet}") @Produces("application/json") public ResponseDataObject<DatasetsWebService.ExpressionExperimentSubSetWithGroupsValueObject> getDatasetSubSetById(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("subSet") Long subSetId)

    • getDatasetSubSetSamples

      @GET @Path("/{dataset}/subSets/{subSet}/samples") @Produces("application/json") public Object getDatasetSubSetSamples(@PathParam("dataset") DatasetArg<?> datasetArg, @PathParam("subSet") Long subSetId, @QueryParam("cursor") CursorArg cursorArg, @QueryParam("limit") LimitArg limitArg, @QueryParam("includePredictedOutliers") @DefaultValue("false") boolean includePredictedOutliers)
      Retrieves the samples of a specific subset of a dataset.

      Step 1u of CURSOR_PAGINATION_STEP1_PLAN.md adds an opt-in cursor-mode branch parallel to step 1k (/datasets/{dataset}/samples). The legacy mode (no cursor) is preserved byte-for-byte: an unpaginated ResponseDataObject<List<BioAssayValueObject>> with the full subset sample list. Cursor mode is available for consistency with the other listings; a subset's assay list itself stays small (single-cell size is in cells, not assays). Cursor mode always sorts by ascending id; the path-derived subSet.id = ? constraint is preserved across modes; totalElements is null by default (no count query per request).