test_class.declarator: cacheManager
test_class.modifier: @Autowired
      private
test_class.original_string: @Autowired
      private ContentCache cacheManager;
test_class.type: ContentCache
test_class.var_name: cacheManager
test_class.declarator: resolver
test_class.modifier: @Autowired
      private
test_class.original_string: @Autowired
      private ResourceResolver resolver;
test_class.type: ResourceResolver
test_class.var_name: resolver
test_class.declarator: quotaService
test_class.modifier: @MockBean
      private
test_class.original_string: @MockBean
      private QuotaService quotaService;
test_class.type: QuotaService
test_class.var_name: quotaService
test_class.file: dataprep-dataset/src/test/java/org/talend/dataprep/dataset/service/DataSetServiceTest.java
test_class.identifier: DataSetServiceTest
test_class.superclass: extends DataSetBaseTest
test_case.body: @Test
      public void testSetUnsetFavoriteDataSet() throws IOException {
          String dsId1 = UUID.randomUUID().toString();
          String dsId2 = UUID.randomUUID().toString();
  
          when().get("/datasets/favorites").then().statusCode(OK.value()).body(equalTo("[]"));
          dataSetMetadataRepository.save(metadataBuilder.metadata().id(dsId1).build());
          dataSetMetadataRepository.save(metadataBuilder.metadata().id(dsId2).build());
          // check set
          when().put("/datasets/{id}/favorite", dsId1).then().statusCode(OK.value());
          when().put("/datasets/{id}/favorite?unset=false", dsId2).then().statusCode(OK.value());
          List<String> favoritesResp = from(when().get("/datasets/favorites").asString()).get(); //$NON-NLS-1$
          assertEquals(2, favoritesResp.size());
          assertThat(favoritesResp, hasItems(dsId1, dsId2));
          // check unset
          when().put("/datasets/{id}/favorite?unset=true", dsId2).then().statusCode(OK.value());
          favoritesResp = from(when().get("/datasets/favorites").asString()).get();
          assertEquals(1, favoritesResp.size());
          assertThat(favoritesResp, hasItem(dsId1));
          // check wrong datasetId
          String wrongDsId = UUID.randomUUID().toString();
          assertThat(dataSetMetadataRepository.get(wrongDsId), nullValue());
          given()
                  .contentType(JSON) //
                  .body(IOUtils.toString(this.getClass().getResourceAsStream(METADATA_JSON), UTF_8)) //
                  .when() //
                  .put("/datasets/{id}/favorite", wrongDsId) //
                  .then() //
                  .statusCode(HttpStatus.NOT_FOUND.value());
  
      }
test_case.class_method_signature: DataSetServiceTest.testSetUnsetFavoriteDataSet()
test_case.full_signature: @Test public void testSetUnsetFavoriteDataSet()
test_case.identifier: testSetUnsetFavoriteDataSet
test_case.invocations: toString randomUUID toString randomUUID body statusCode then get when value equalTo save build id metadata save build id metadata statusCode then put when value statusCode then put when value get from asString get when assertEquals size assertThat hasItems statusCode then put when value get from asString get when assertEquals size assertThat hasItem toString randomUUID assertThat get nullValue statusCode then put when body contentType given toString getResourceAsStream getClass value
test_case.modifiers: @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void testSetUnsetFavoriteDataSet()
focal_class.declarator: LOG = LoggerFactory.getLogger(DataSetService.class)
focal_class.modifier: private static final
focal_class.original_string: private static final Logger LOG = LoggerFactory.getLogger(DataSetService.class);
focal_class.type: Logger
focal_class.var_name: LOG
focal_class.declarator: CONTENT_TYPE = "Content-Type"
focal_class.modifier: private static final
focal_class.original_string: private static final String CONTENT_TYPE = "Content-Type";
focal_class.type: String
focal_class.var_name: CONTENT_TYPE
focal_class.declarator: STORAGE_LIMIT = "limit"
focal_class.modifier: private static final
focal_class.original_string: private static final String STORAGE_LIMIT = "limit";
focal_class.type: String
focal_class.var_name: STORAGE_LIMIT
focal_class.declarator: formatAnalyzer
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private FormatAnalysis formatAnalyzer;
focal_class.type: FormatAnalysis
focal_class.var_name: formatAnalyzer
focal_class.declarator: userDataRepository
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private UserDataRepository userDataRepository;
focal_class.type: UserDataRepository
focal_class.var_name: userDataRepository
focal_class.declarator: formatFamilyFactory
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private FormatFamilyFactory formatFamilyFactory;
focal_class.type: FormatFamilyFactory
focal_class.var_name: formatFamilyFactory
focal_class.declarator: datasetLocator
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private DataSetLocatorService datasetLocator;
focal_class.type: DataSetLocatorService
focal_class.var_name: datasetLocator
focal_class.declarator: security
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private Security security;
focal_class.type: Security
focal_class.var_name: security
focal_class.declarator: locationsService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private DataSetLocationService locationsService;
focal_class.type: DataSetLocationService
focal_class.var_name: locationsService
focal_class.declarator: versionService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private VersionService versionService;
focal_class.type: VersionService
focal_class.var_name: versionService
focal_class.declarator: conversionService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private BeanConversionService conversionService;
focal_class.type: BeanConversionService
focal_class.var_name: conversionService
focal_class.declarator: quotaService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private QuotaService quotaService;
focal_class.type: QuotaService
focal_class.var_name: quotaService
focal_class.declarator: enabledImports
focal_class.modifier: @Value("#{'${dataset.imports}'.split(',')}")
      private
focal_class.original_string: @Value("#{'${dataset.imports}'.split(',')}")
      private Set<String> enabledImports;
focal_class.type: Set<String>
focal_class.var_name: enabledImports
focal_class.declarator: datasetListLimit
focal_class.modifier: @Value("${dataset.list.limit:10}")
      private
focal_class.original_string: @Value("${dataset.list.limit:10}")
      private int datasetListLimit;
focal_class.type: int
focal_class.var_name: datasetListLimit
focal_class.declarator: analyzerService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private AnalyzerService analyzerService;
focal_class.type: AnalyzerService
focal_class.var_name: analyzerService
focal_class.declarator: filterService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private FilterService filterService;
focal_class.type: FilterService
focal_class.var_name: filterService
focal_class.declarator: maximumInputStreamSize
focal_class.modifier: @Value("${dataset.local.file.size.limit:20000000}")
      private
focal_class.original_string: @Value("${dataset.local.file.size.limit:20000000}")
      private long maximumInputStreamSize;
focal_class.type: long
focal_class.var_name: maximumInputStreamSize
focal_class.declarator: cacheManager
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private ContentCache cacheManager;
focal_class.type: ContentCache
focal_class.var_name: cacheManager
focal_class.declarator: executor
focal_class.modifier: @Resource(name = "serializer#dataset#executor")
      private
focal_class.original_string: @Resource(name = "serializer#dataset#executor")
      private TaskExecutor executor;
focal_class.type: TaskExecutor
focal_class.var_name: executor
focal_class.declarator: securityProxy
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private SecurityProxy securityProxy;
focal_class.type: SecurityProxy
focal_class.var_name: securityProxy
focal_class.declarator: beanConversionService
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private BeanConversionService beanConversionService;
focal_class.type: BeanConversionService
focal_class.var_name: beanConversionService
focal_class.declarator: dataSetContentLimit
focal_class.modifier: @Autowired
      private
focal_class.original_string: @Autowired
      private DataSetContentLimit dataSetContentLimit;
focal_class.type: DataSetContentLimit
focal_class.var_name: dataSetContentLimit
focal_class.file: dataprep-dataset/src/main/java/org/talend/dataprep/dataset/service/DataSetService.java
focal_class.identifier: DataSetService
focal_class.class_method_signature: DataSetService.list(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.full_signature: @RequestMapping(value = "/datasets", method = RequestMethod.GET) @ApiOperation(value = "List all data sets and filters on certified, or favorite or a limited number when asked", notes = "Returns the list of data sets (and filters) the current user is allowed to see. Creation date is a Epoch time value (in UTC time zone).") @Timed public Stream<DatasetDTO> list(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.identifier: list
focal_class.modifiers: @RequestMapping(value = "/datasets", method = RequestMethod.GET) @ApiOperation(value = "List all data sets and filters on certified, or favorite or a limited number when asked", notes = "Returns the list of data sets (and filters) the current user is allowed to see. Creation date is a Epoch time value (in UTC time zone).") @Timed public
focal_class.parameters: (
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.return: Stream<DatasetDTO>
focal_class.signature: Stream<DatasetDTO> list(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.class_method_signature: DataSetService.injectFavorite(Set<String> favoritesDatasets)
focal_class.full_signature: private BiFunction<DataSetMetadata, DatasetDTO, DatasetDTO> injectFavorite(Set<String> favoritesDatasets)
focal_class.identifier: injectFavorite
focal_class.modifiers: private
focal_class.parameters: (Set<String> favoritesDatasets)
focal_class.return: BiFunction<DataSetMetadata, DatasetDTO, DatasetDTO>
focal_class.signature: BiFunction<DataSetMetadata, DatasetDTO, DatasetDTO> injectFavorite(Set<String> favoritesDatasets)
focal_class.class_method_signature: DataSetService.listWithFullDetails(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.full_signature: @RequestMapping(value = "/datasets/details", method = RequestMethod.GET) @ApiOperation(value = "List all data sets and filters on certified, or favorite or a limited number when asked", notes = "Returns the list of data sets (and filters) the current user is allowed to see. Creation date is a Epoch time value (in UTC time zone).") @Timed public Stream<UserDataSetMetadata> listWithFullDetails(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.identifier: listWithFullDetails
focal_class.modifiers: @RequestMapping(value = "/datasets/details", method = RequestMethod.GET) @ApiOperation(value = "List all data sets and filters on certified, or favorite or a limited number when asked", notes = "Returns the list of data sets (and filters) the current user is allowed to see. Creation date is a Epoch time value (in UTC time zone).") @Timed public
focal_class.parameters: (
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.return: Stream<UserDataSetMetadata>
focal_class.signature: Stream<UserDataSetMetadata> listWithFullDetails(
              @ApiParam(value = "Sort key (by name, creation or modification date)") @RequestParam(
                      defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc or modif)") @RequestParam(
                      defaultValue = "desc") Order order,
              @ApiParam(value = "Filter on name containing the specified name") @RequestParam(
                      required = false) String name,
              @ApiParam(value = "Filter on name containing the specified name strictness") @RequestParam(
                      defaultValue = "false") boolean nameStrict,
              @ApiParam(value = "Filter on certified data sets") @RequestParam(defaultValue = "false") boolean certified,
              @ApiParam(value = "Filter on favorite data sets") @RequestParam(defaultValue = "false") boolean favorite,
              @ApiParam(value = "Only return a limited number of data sets") @RequestParam(
                      defaultValue = "false") boolean limit)
focal_class.class_method_signature: DataSetService.listCompatibleDatasets(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set metadata") String dataSetId,
              @ApiParam(value = "Sort key (by name or date).") @RequestParam(defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc).") @RequestParam(defaultValue = "desc") Order order)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/compatibledatasets", method = RequestMethod.GET) @ApiOperation(value = "List all compatible data sets", notes = "Returns the list of data sets the current user is allowed to see and which are compatible with the specified data set id.") @Timed public Iterable<UserDataSetMetadata> listCompatibleDatasets(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set metadata") String dataSetId,
              @ApiParam(value = "Sort key (by name or date).") @RequestParam(defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc).") @RequestParam(defaultValue = "desc") Order order)
focal_class.identifier: listCompatibleDatasets
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/compatibledatasets", method = RequestMethod.GET) @ApiOperation(value = "List all compatible data sets", notes = "Returns the list of data sets the current user is allowed to see and which are compatible with the specified data set id.") @Timed public
focal_class.parameters: (
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set metadata") String dataSetId,
              @ApiParam(value = "Sort key (by name or date).") @RequestParam(defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc).") @RequestParam(defaultValue = "desc") Order order)
focal_class.return: Iterable<UserDataSetMetadata>
focal_class.signature: Iterable<UserDataSetMetadata> listCompatibleDatasets(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set metadata") String dataSetId,
              @ApiParam(value = "Sort key (by name or date).") @RequestParam(defaultValue = "creationDate") Sort sort,
              @ApiParam(value = "Order for sort key (desc or asc).") @RequestParam(defaultValue = "desc") Order order)
focal_class.class_method_signature: DataSetService.create(
              @ApiParam(value = "User readable name of the data set (e.g. 'Finance Report 2015', 'Test Data Set').") @RequestParam(defaultValue = "") String name,
              @ApiParam(value = "An optional tag to be added in data set metadata once created.") @RequestParam(defaultValue = "") String tag,
              @ApiParam(value = "Size of the data set, in bytes.") @RequestParam(required = false) Long size,
              @RequestHeader(CONTENT_TYPE) String contentType,
              @ApiParam(value = "content") InputStream content)
focal_class.full_signature: @RequestMapping(value = "/datasets", method = POST, produces = TEXT_PLAIN_VALUE) @ApiOperation(value = "Create a data set", produces = TEXT_PLAIN_VALUE, notes = "Create a new data set based on content provided in POST body. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too. Returns the id of the newly created data set.") @Timed @VolumeMetered public String create(
              @ApiParam(value = "User readable name of the data set (e.g. 'Finance Report 2015', 'Test Data Set').") @RequestParam(defaultValue = "") String name,
              @ApiParam(value = "An optional tag to be added in data set metadata once created.") @RequestParam(defaultValue = "") String tag,
              @ApiParam(value = "Size of the data set, in bytes.") @RequestParam(required = false) Long size,
              @RequestHeader(CONTENT_TYPE) String contentType,
              @ApiParam(value = "content") InputStream content)
focal_class.identifier: create
focal_class.modifiers: @RequestMapping(value = "/datasets", method = POST, produces = TEXT_PLAIN_VALUE) @ApiOperation(value = "Create a data set", produces = TEXT_PLAIN_VALUE, notes = "Create a new data set based on content provided in POST body. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too. Returns the id of the newly created data set.") @Timed @VolumeMetered public
focal_class.parameters: (
              @ApiParam(value = "User readable name of the data set (e.g. 'Finance Report 2015', 'Test Data Set').") @RequestParam(defaultValue = "") String name,
              @ApiParam(value = "An optional tag to be added in data set metadata once created.") @RequestParam(defaultValue = "") String tag,
              @ApiParam(value = "Size of the data set, in bytes.") @RequestParam(required = false) Long size,
              @RequestHeader(CONTENT_TYPE) String contentType,
              @ApiParam(value = "content") InputStream content)
focal_class.return: String
focal_class.signature: String create(
              @ApiParam(value = "User readable name of the data set (e.g. 'Finance Report 2015', 'Test Data Set').") @RequestParam(defaultValue = "") String name,
              @ApiParam(value = "An optional tag to be added in data set metadata once created.") @RequestParam(defaultValue = "") String tag,
              @ApiParam(value = "Size of the data set, in bytes.") @RequestParam(required = false) Long size,
              @RequestHeader(CONTENT_TYPE) String contentType,
              @ApiParam(value = "content") InputStream content)
focal_class.class_method_signature: DataSetService.get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/content", method = RequestMethod.GET) @ApiOperation(value = "Get a data set by id", notes = "Get a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public Callable<DataSet> get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_class.identifier: get
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/content", method = RequestMethod.GET) @ApiOperation(value = "Get a data set by id", notes = "Get a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public
focal_class.parameters: (
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_class.return: Callable<DataSet>
focal_class.signature: Callable<DataSet> get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_class.class_method_signature: DataSetService.insertWordPatternAnalysis(DataSetMetadata dataSetMetadata, Stream<DataSetRow> records)
focal_class.full_signature: private Stream<DataSetRow> insertWordPatternAnalysis(DataSetMetadata dataSetMetadata, Stream<DataSetRow> records)
focal_class.identifier: insertWordPatternAnalysis
focal_class.modifiers: private
focal_class.parameters: (DataSetMetadata dataSetMetadata, Stream<DataSetRow> records)
focal_class.return: Stream<DataSetRow>
focal_class.signature: Stream<DataSetRow> insertWordPatternAnalysis(DataSetMetadata dataSetMetadata, Stream<DataSetRow> records)
focal_class.class_method_signature: DataSetService.getMetadata(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set metadata") String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/metadata", method = RequestMethod.GET) @ApiOperation(value = "Get metadata information of a data set by id", notes = "Get metadata information of a data set by id. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public DataSet getMetadata(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set metadata") String dataSetId)
focal_class.identifier: getMetadata
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/metadata", method = RequestMethod.GET) @ApiOperation(value = "Get metadata information of a data set by id", notes = "Get metadata information of a data set by id. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public
focal_class.parameters: (@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set metadata") String dataSetId)
focal_class.return: DataSet
focal_class.signature: DataSet getMetadata(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set metadata") String dataSetId)
focal_class.class_method_signature: DataSetService.delete(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set to delete") String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}", method = RequestMethod.DELETE) @ApiOperation(value = "Delete a data set by id", notes = "Delete a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed public void delete(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set to delete") String dataSetId)
focal_class.identifier: delete
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}", method = RequestMethod.DELETE) @ApiOperation(value = "Delete a data set by id", notes = "Delete a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed public
focal_class.parameters: (@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set to delete") String dataSetId)
focal_class.return: void
focal_class.signature: void delete(@PathVariable(value = "id") @ApiParam(name = "id",
              value = "Id of the data set to delete") String dataSetId)
focal_class.class_method_signature: DataSetService.copy(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to clone") String dataSetId,
              @ApiParam(value = "The name of the cloned dataset.") @RequestParam(required = false) String copyName)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/copy", method = POST, produces = TEXT_PLAIN_VALUE) @ApiOperation(value = "Copy a data set", produces = TEXT_PLAIN_VALUE, notes = "Copy a new data set based on the given id. Returns the id of the newly created data set.") @Timed public String copy(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to clone") String dataSetId,
              @ApiParam(value = "The name of the cloned dataset.") @RequestParam(required = false) String copyName)
focal_class.identifier: copy
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/copy", method = POST, produces = TEXT_PLAIN_VALUE) @ApiOperation(value = "Copy a data set", produces = TEXT_PLAIN_VALUE, notes = "Copy a new data set based on the given id. Returns the id of the newly created data set.") @Timed public
focal_class.parameters: (
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to clone") String dataSetId,
              @ApiParam(value = "The name of the cloned dataset.") @RequestParam(required = false) String copyName)
focal_class.return: String
focal_class.signature: String copy(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to clone") String dataSetId,
              @ApiParam(value = "The name of the cloned dataset.") @RequestParam(required = false) String copyName)
focal_class.class_method_signature: DataSetService.updateRawDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId, //
              @RequestParam(value = "name", required = false) @ApiParam(name = "name",
                      value = "New value for the data set name") String name, //
              @RequestParam(value = "size", required = false) @ApiParam(name = "size",
                      value = "The size of the dataSet") Long size, //
              @ApiParam(value = "content") InputStream dataSetContent)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/raw", method = PUT) @ApiOperation(value = "Update a data set by id", notes = "Update a data set content based on provided id and PUT body. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too.") @Timed @VolumeMetered public String updateRawDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId, //
              @RequestParam(value = "name", required = false) @ApiParam(name = "name",
                      value = "New value for the data set name") String name, //
              @RequestParam(value = "size", required = false) @ApiParam(name = "size",
                      value = "The size of the dataSet") Long size, //
              @ApiParam(value = "content") InputStream dataSetContent)
focal_class.identifier: updateRawDataSet
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/raw", method = PUT) @ApiOperation(value = "Update a data set by id", notes = "Update a data set content based on provided id and PUT body. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too.") @Timed @VolumeMetered public
focal_class.parameters: (
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId, //
              @RequestParam(value = "name", required = false) @ApiParam(name = "name",
                      value = "New value for the data set name") String name, //
              @RequestParam(value = "size", required = false) @ApiParam(name = "size",
                      value = "The size of the dataSet") Long size, //
              @ApiParam(value = "content") InputStream dataSetContent)
focal_class.return: String
focal_class.signature: String updateRawDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId, //
              @RequestParam(value = "name", required = false) @ApiParam(name = "name",
                      value = "New value for the data set name") String name, //
              @RequestParam(value = "size", required = false) @ApiParam(name = "size",
                      value = "The size of the dataSet") Long size, //
              @ApiParam(value = "content") InputStream dataSetContent)
focal_class.class_method_signature: DataSetService.dataSetContentToNull(InputStream content)
focal_class.full_signature: private void dataSetContentToNull(InputStream content)
focal_class.identifier: dataSetContentToNull
focal_class.modifiers: private
focal_class.parameters: (InputStream content)
focal_class.return: void
focal_class.signature: void dataSetContentToNull(InputStream content)
focal_class.class_method_signature: DataSetService.listErrors()
focal_class.full_signature: @RequestMapping(value = "/datasets/errors", method = RequestMethod.GET) @ApiOperation(value = "Get all dataset related error codes.", notes = "Returns the list of all dataset related error codes.") @Timed public Iterable<JsonErrorCodeDescription> listErrors()
focal_class.identifier: listErrors
focal_class.modifiers: @RequestMapping(value = "/datasets/errors", method = RequestMethod.GET) @ApiOperation(value = "Get all dataset related error codes.", notes = "Returns the list of all dataset related error codes.") @Timed public
focal_class.parameters: ()
focal_class.return: Iterable<JsonErrorCodeDescription>
focal_class.signature: Iterable<JsonErrorCodeDescription> listErrors()
focal_class.class_method_signature: DataSetService.preview(@RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
                      @RequestParam(defaultValue = "") @ApiParam(name = "sheetName",
                              value = "Sheet name to preview") String sheetName, //
                      @PathVariable(value = "id") @ApiParam(name = "id",
                              value = "Id of the requested data set") String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/preview", method = RequestMethod.GET) @ApiOperation(value = "Get a data preview set by id", notes = "Get a data set preview content based on provided id. Not valid or non existing data set id returns empty content. Data set not in drat status will return a redirect 301") @Timed @ResponseBody public DataSet preview(@RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
                      @RequestParam(defaultValue = "") @ApiParam(name = "sheetName",
                              value = "Sheet name to preview") String sheetName, //
                      @PathVariable(value = "id") @ApiParam(name = "id",
                              value = "Id of the requested data set") String dataSetId)
focal_class.identifier: preview
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/preview", method = RequestMethod.GET) @ApiOperation(value = "Get a data preview set by id", notes = "Get a data set preview content based on provided id. Not valid or non existing data set id returns empty content. Data set not in drat status will return a redirect 301") @Timed @ResponseBody public
focal_class.parameters: (@RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
                      @RequestParam(defaultValue = "") @ApiParam(name = "sheetName",
                              value = "Sheet name to preview") String sheetName, //
                      @PathVariable(value = "id") @ApiParam(name = "id",
                              value = "Id of the requested data set") String dataSetId)
focal_class.return: DataSet
focal_class.signature: DataSet preview(@RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
                      @RequestParam(defaultValue = "") @ApiParam(name = "sheetName",
                              value = "Sheet name to preview") String sheetName, //
                      @PathVariable(value = "id") @ApiParam(name = "id",
                              value = "Id of the requested data set") String dataSetId)
focal_class.class_method_signature: DataSetService.updateDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId,
              @RequestBody DataSetMetadata dataSetMetadata)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}", method = PUT) @ApiOperation(value = "Update a data set metadata by id", notes = "Update a data set metadata according to the content of the PUT body. Id should be a UUID returned by the list operation. Not valid or non existing data set id return an error response.") @Timed public void updateDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId,
              @RequestBody DataSetMetadata dataSetMetadata)
focal_class.identifier: updateDataSet
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}", method = PUT) @ApiOperation(value = "Update a data set metadata by id", notes = "Update a data set metadata according to the content of the PUT body. Id should be a UUID returned by the list operation. Not valid or non existing data set id return an error response.") @Timed public
focal_class.parameters: (
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId,
              @RequestBody DataSetMetadata dataSetMetadata)
focal_class.return: void
focal_class.signature: void updateDataSet(
              @PathVariable(value = "id") @ApiParam(name = "id", value = "Id of the data set to update") String dataSetId,
              @RequestBody DataSetMetadata dataSetMetadata)
focal_class.class_method_signature: DataSetService.favorites()
focal_class.full_signature: @RequestMapping(value = "/datasets/favorites", method = RequestMethod.GET) @ApiOperation(value = "return all favorites datasets of the current user", notes = "Returns the list of favorites datasets.") @Timed public Iterable<String> favorites()
focal_class.identifier: favorites
focal_class.modifiers: @RequestMapping(value = "/datasets/favorites", method = RequestMethod.GET) @ApiOperation(value = "return all favorites datasets of the current user", notes = "Returns the list of favorites datasets.") @Timed public
focal_class.parameters: ()
focal_class.return: Iterable<String>
focal_class.signature: Iterable<String> favorites()
focal_class.class_method_signature: DataSetService.setFavorites(@RequestParam(defaultValue = "false") @ApiParam(name = "unset",
              value = "if true then unset the dataset as favorite, if false (default value) set the favorite flag") boolean unset, //
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the favorite data set, do nothing is the id does not exist.") String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/favorite", method = PUT) @ApiOperation(value = "set or unset a dataset as favorite", notes = "Specify if a dataset is or is not a favorite for the current user.") @Timed public void setFavorites(@RequestParam(defaultValue = "false") @ApiParam(name = "unset",
              value = "if true then unset the dataset as favorite, if false (default value) set the favorite flag") boolean unset, //
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the favorite data set, do nothing is the id does not exist.") String dataSetId)
focal_class.identifier: setFavorites
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/favorite", method = PUT) @ApiOperation(value = "set or unset a dataset as favorite", notes = "Specify if a dataset is or is not a favorite for the current user.") @Timed public
focal_class.parameters: (@RequestParam(defaultValue = "false") @ApiParam(name = "unset",
              value = "if true then unset the dataset as favorite, if false (default value) set the favorite flag") boolean unset, //
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the favorite data set, do nothing is the id does not exist.") String dataSetId)
focal_class.return: void
focal_class.signature: void setFavorites(@RequestParam(defaultValue = "false") @ApiParam(name = "unset",
              value = "if true then unset the dataset as favorite, if false (default value) set the favorite flag") boolean unset, //
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the favorite data set, do nothing is the id does not exist.") String dataSetId)
focal_class.class_method_signature: DataSetService.updateDatasetColumn(
              @PathVariable(value = "datasetId") @ApiParam(name = "datasetId",
                      value = "Id of the dataset") final String dataSetId,
              @PathVariable(value = "columnId") @ApiParam(name = "columnId",
                      value = "Id of the column") final String columnId,
              @RequestBody final UpdateColumnParameters parameters)
focal_class.full_signature: @RequestMapping(value = "/datasets/{datasetId}/column/{columnId}", method = POST) @ApiOperation(value = "Update a column type and/or domain") @Timed public void updateDatasetColumn(
              @PathVariable(value = "datasetId") @ApiParam(name = "datasetId",
                      value = "Id of the dataset") final String dataSetId,
              @PathVariable(value = "columnId") @ApiParam(name = "columnId",
                      value = "Id of the column") final String columnId,
              @RequestBody final UpdateColumnParameters parameters)
focal_class.identifier: updateDatasetColumn
focal_class.modifiers: @RequestMapping(value = "/datasets/{datasetId}/column/{columnId}", method = POST) @ApiOperation(value = "Update a column type and/or domain") @Timed public
focal_class.parameters: (
              @PathVariable(value = "datasetId") @ApiParam(name = "datasetId",
                      value = "Id of the dataset") final String dataSetId,
              @PathVariable(value = "columnId") @ApiParam(name = "columnId",
                      value = "Id of the column") final String columnId,
              @RequestBody final UpdateColumnParameters parameters)
focal_class.return: void
focal_class.signature: void updateDatasetColumn(
              @PathVariable(value = "datasetId") @ApiParam(name = "datasetId",
                      value = "Id of the dataset") final String dataSetId,
              @PathVariable(value = "columnId") @ApiParam(name = "columnId",
                      value = "Id of the column") final String columnId,
              @RequestBody final UpdateColumnParameters parameters)
focal_class.class_method_signature: DataSetService.search( //
              @RequestParam @ApiParam(value = "What to search in data sets") final String name, //
              @RequestParam @ApiParam(value = "The searched name should be the full name") final boolean strict)
focal_class.full_signature: @RequestMapping(value = "/datasets/search", method = GET) @ApiOperation(value = "Search the dataset metadata", notes = "Search the dataset metadata.") @Timed @Deprecated public Stream<DatasetDTO> search( //
              @RequestParam @ApiParam(value = "What to search in data sets") final String name, //
              @RequestParam @ApiParam(value = "The searched name should be the full name") final boolean strict)
focal_class.identifier: search
focal_class.modifiers: @RequestMapping(value = "/datasets/search", method = GET) @ApiOperation(value = "Search the dataset metadata", notes = "Search the dataset metadata.") @Timed @Deprecated public
focal_class.parameters: ( //
              @RequestParam @ApiParam(value = "What to search in data sets") final String name, //
              @RequestParam @ApiParam(value = "The searched name should be the full name") final boolean strict)
focal_class.return: Stream<DatasetDTO>
focal_class.signature: Stream<DatasetDTO> search( //
              @RequestParam @ApiParam(value = "What to search in data sets") final String name, //
              @RequestParam @ApiParam(value = "The searched name should be the full name") final boolean strict)
focal_class.class_method_signature: DataSetService.getImportParameters(@PathVariable("import") final String importType)
focal_class.full_signature: @RequestMapping(value = "/datasets/imports/{import}/parameters", method = GET, produces = APPLICATION_JSON_VALUE) @ApiOperation(value = "Get the import parameters", notes = "This list can be used by user to change dataset encoding.") @Timed @PublicAPI // This method have to return Object because it can either return the legacy List<Parameter> or the new TComp // oriented // ComponentProperties public Object getImportParameters(@PathVariable("import") final String importType)
focal_class.identifier: getImportParameters
focal_class.modifiers: @RequestMapping(value = "/datasets/imports/{import}/parameters", method = GET, produces = APPLICATION_JSON_VALUE) @ApiOperation(value = "Get the import parameters", notes = "This list can be used by user to change dataset encoding.") @Timed @PublicAPI // This method have to return Object because it can either return the legacy List<Parameter> or the new TComp // oriented // ComponentProperties public
focal_class.parameters: (@PathVariable("import") final String importType)
focal_class.return: Object
focal_class.signature: Object getImportParameters(@PathVariable("import") final String importType)
focal_class.class_method_signature: DataSetService.getDataStoreParameters(@PathVariable("id") final String dataSetId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{id}/datastore/properties", method = GET) @ApiOperation(value = "Get the dataset import parameters", notes = "This list can be used by user to change dataset encoding.") @Timed // This method have to return Object because it can either return the legacy List<Parameter> or the new TComp // oriented // ComponentProperties public Object getDataStoreParameters(@PathVariable("id") final String dataSetId)
focal_class.identifier: getDataStoreParameters
focal_class.modifiers: @RequestMapping(value = "/datasets/{id}/datastore/properties", method = GET) @ApiOperation(value = "Get the dataset import parameters", notes = "This list can be used by user to change dataset encoding.") @Timed // This method have to return Object because it can either return the legacy List<Parameter> or the new TComp // oriented // ComponentProperties public
focal_class.parameters: (@PathVariable("id") final String dataSetId)
focal_class.return: Object
focal_class.signature: Object getDataStoreParameters(@PathVariable("id") final String dataSetId)
focal_class.class_method_signature: DataSetService.listSupportedImports()
focal_class.full_signature: @RequestMapping(value = "/datasets/imports", method = GET) @ApiOperation(value = "list the supported encodings for dataset", notes = "This list can be used by user to change dataset encoding.") @Timed @PublicAPI public Stream<Import> listSupportedImports()
focal_class.identifier: listSupportedImports
focal_class.modifiers: @RequestMapping(value = "/datasets/imports", method = GET) @ApiOperation(value = "list the supported encodings for dataset", notes = "This list can be used by user to change dataset encoding.") @Timed @PublicAPI public
focal_class.parameters: ()
focal_class.return: Stream<Import>
focal_class.signature: Stream<Import> listSupportedImports()
focal_class.class_method_signature: DataSetService.getDataSetColumnSemanticCategories(
              @ApiParam(value = "The dataset id") @PathVariable String datasetId,
              @ApiParam(value = "The column id") @PathVariable String columnId)
focal_class.full_signature: @RequestMapping(value = "/datasets/{datasetId}/columns/{columnId}/types", method = GET) @ApiOperation(value = "list the types of the wanted column", notes = "This list can be used by user to change the column type.") @Timed @PublicAPI public List<SemanticDomain> getDataSetColumnSemanticCategories(
              @ApiParam(value = "The dataset id") @PathVariable String datasetId,
              @ApiParam(value = "The column id") @PathVariable String columnId)
focal_class.identifier: getDataSetColumnSemanticCategories
focal_class.modifiers: @RequestMapping(value = "/datasets/{datasetId}/columns/{columnId}/types", method = GET) @ApiOperation(value = "list the types of the wanted column", notes = "This list can be used by user to change the column type.") @Timed @PublicAPI public
focal_class.parameters: (
              @ApiParam(value = "The dataset id") @PathVariable String datasetId,
              @ApiParam(value = "The column id") @PathVariable String columnId)
focal_class.return: List<SemanticDomain>
focal_class.signature: List<SemanticDomain> getDataSetColumnSemanticCategories(
              @ApiParam(value = "The dataset id") @PathVariable String datasetId,
              @ApiParam(value = "The column id") @PathVariable String columnId)
focal_class.class_method_signature: DataSetService.checkDataSetName(String dataSetName)
focal_class.full_signature: private void checkDataSetName(String dataSetName)
focal_class.identifier: checkDataSetName
focal_class.modifiers: private
focal_class.parameters: (String dataSetName)
focal_class.return: void
focal_class.signature: void checkDataSetName(String dataSetName)
focal_class.class_method_signature: DataSetService.getMaxDataSetSizeAllowed()
focal_class.full_signature: private long getMaxDataSetSizeAllowed()
focal_class.identifier: getMaxDataSetSizeAllowed
focal_class.modifiers: private
focal_class.parameters: ()
focal_class.return: long
focal_class.signature: long getMaxDataSetSizeAllowed()
focal_class.class_method_signature: DataSetService.findDataset(Sort sort, Order order, String name, boolean nameStrict,
              boolean certified, boolean favorite, boolean limit, Set<String> favoritesIds)
focal_class.full_signature: private Stream<DataSetMetadata> findDataset(Sort sort, Order order, String name, boolean nameStrict,
              boolean certified, boolean favorite, boolean limit, Set<String> favoritesIds)
focal_class.identifier: findDataset
focal_class.modifiers: private
focal_class.parameters: (Sort sort, Order order, String name, boolean nameStrict,
              boolean certified, boolean favorite, boolean limit, Set<String> favoritesIds)
focal_class.return: Stream<DataSetMetadata>
focal_class.signature: Stream<DataSetMetadata> findDataset(Sort sort, Order order, String name, boolean nameStrict,
              boolean certified, boolean favorite, boolean limit, Set<String> favoritesIds)
focal_class.superclass: extends BaseDataSetService
focal_method.body: @RequestMapping(value = "/datasets/{id}/content", method = RequestMethod.GET)
      @ApiOperation(value = "Get a data set by id",
              notes = "Get a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.")
      @Timed
      @ResponseBody
      public Callable<DataSet> get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId) {
          return () -> {
              final Marker marker = Markers.dataset(dataSetId);
              LOG.debug(marker, "Get data set #{}", dataSetId);
              Stream<DataSetRow> stream = null;
              try {
                  DataSetMetadata dataSetMetadata = dataSetMetadataRepository.get(dataSetId);
                  assertDataSetMetadata(dataSetMetadata, dataSetId);
                  // Build the result
                  DataSet dataSet = new DataSet();
                  if (metadata) {
                      dataSet.setMetadata(conversionService.convert(dataSetMetadata, UserDataSetMetadata.class));
                  }
                  stream = contentStore.stream(dataSetMetadata, limit); // Disable line limit
  
                  // on-demand analyzer for dataset (See TDP-4404, migration problems)
                  if (dataSetMetadata.getRowMetadata().getColumns().stream().anyMatch(
                          c -> c.getStatistics().getWordPatternFrequencyTable().isEmpty())) {
                      stream = insertWordPatternAnalysis(dataSetMetadata, stream);
                  }
  
                  if (!includeInternalContent) {
                      LOG.debug("Skip internal content when serving data set #{} content.", dataSetId);
                      stream = stream.map(r -> {
                          final Map<String, Object> values = r.values();
                          final Map<String, Object> filteredValues = new HashMap<>(values);
                          // Remove technical properties from returned values.
                          values.forEach((k, v) -> {
                              if (k != null && k.startsWith(FlagNames.INTERNAL_PROPERTY_PREFIX)) {
                                  filteredValues.remove(k);
                              }
                          });
                          filteredValues.put(FlagNames.TDP_ID, r.getTdpId()); // Include TDP_ID anyway
                          return new DataSetRow(r.getRowMetadata(), filteredValues);
                      });
                  }
  
                  // Filter content
                  stream = stream.filter(filterService.build(filter, dataSetMetadata.getRowMetadata()));
  
                  dataSet.setRecords(stream);
                  return dataSet;
              } catch (Exception e) {
                  if (stream != null) {
                      stream.close();
                  }
                  throw e;
              } finally {
                  LOG.debug(marker, "Get done.");
              }
          };
      }
focal_method.class_method_signature: DataSetService.get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_method.full_signature: @RequestMapping(value = "/datasets/{id}/content", method = RequestMethod.GET) @ApiOperation(value = "Get a data set by id", notes = "Get a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public Callable<DataSet> get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_method.identifier: get
focal_method.invocations: dataset debug get assertDataSetMetadata setMetadata convert stream anyMatch stream getColumns getRowMetadata isEmpty getWordPatternFrequencyTable getStatistics insertWordPatternAnalysis debug map values forEach startsWith remove put getTdpId getRowMetadata filter build getRowMetadata setRecords close debug
focal_method.modifiers: @RequestMapping(value = "/datasets/{id}/content", method = RequestMethod.GET) @ApiOperation(value = "Get a data set by id", notes = "Get a data set content based on provided id. Id should be a UUID returned by the list operation. Not valid or non existing data set id returns empty content.") @Timed @ResponseBody public
focal_method.parameters: (
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)
focal_method.return: Callable<DataSet>
focal_method.signature: Callable<DataSet> get(
              @RequestParam(defaultValue = "true") @ApiParam(name = "metadata",
                      value = "Include metadata information in the response") boolean metadata, //
              @RequestParam(defaultValue = "false") @ApiParam(name = "includeInternalContent",
                      value = "Include internal content in the response") boolean includeInternalContent, //
              @RequestParam(defaultValue = "-1") @ApiParam(name = STORAGE_LIMIT, value = STORAGE_LIMIT) long limit, //
              @ApiParam(value = "Filter for retrieved content.") @RequestParam(value = "filter",
                      defaultValue = "") String filter,
              @PathVariable(value = "id") @ApiParam(name = "id",
                      value = "Id of the requested data set") String dataSetId)