diff --git a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserController.js b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserController.js
index 511531b6a5ed5109be823b7cb1e3f86becdfad79..f59af8844edde5293776e93ff79890b4df87ed20 100644
--- a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserController.js
+++ b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserController.js
@@ -1,7 +1,6 @@
import BrowserController from '@src/js/components/common/browser2/BrowserController.js'
import TypeBrowserControllerLoadNodePath from '@src/js/components/types/browser2/TypeBrowserControllerLoadNodePath.js'
-import TypeBrowserControllerLoadNodesFiltered from '@src/js/components/types/browser2/TypeBrowserControllerLoadNodesFiltered.js'
-import TypeBrowserControllerLoadNodesUnfiltered from '@src/js/components/types/browser2/TypeBrowserControllerLoadNodesUnfiltered.js'
+import TypeBrowserControllerLoadNodes from '@src/js/components/types/browser2/TypeBrowserControllerLoadNodes.js'
import TypeBrowserControllerAddNode from '@src/js/components/types/browser2/TypeBrowserControllerAddNode.js'
import TypeBrowserControllerRemoveNode from '@src/js/components/types/browser2/TypeBrowserControllerRemoveNode.js'
import TypeBrowserControllerReload from '@src/js/components/types/browser2/TypeBrowserControllerReload.js'
@@ -12,17 +11,7 @@ export default class TypeBrowserController extends BrowserController {
}
async doLoadNodes(params) {
- const { filter } = params
-
- if (filter) {
- return await new TypeBrowserControllerLoadNodesFiltered().doLoadFilteredNodes(
- params
- )
- } else {
- return await new TypeBrowserControllerLoadNodesUnfiltered().doLoadUnfilteredNodes(
- params
- )
- }
+ return await new TypeBrowserControllerLoadNodes().doLoadNodes(params)
}
async reload(objectModifications) {
diff --git a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodePath.js b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodePath.js
index 6dbea1ea9897c49611f898d8f7d959bf7e32f4a8..03292d84422bd4f3cf52528251857f3bc12b5464 100644
--- a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodePath.js
+++ b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodePath.js
@@ -45,7 +45,7 @@ export default class TypeBrowserConstsLoadNodePath {
const types = await openbis.getSampleTypes([id], fetchOptions)
const type = types[object.id]
- return this.createTypePath(
+ return this.createNodePath(
object,
type,
objectType.OBJECT_TYPE,
@@ -58,7 +58,7 @@ export default class TypeBrowserConstsLoadNodePath {
const types = await openbis.getExperimentTypes([id], fetchOptions)
const type = types[object.id]
- return this.createTypePath(
+ return this.createNodePath(
object,
type,
objectType.COLLECTION_TYPE,
@@ -71,7 +71,7 @@ export default class TypeBrowserConstsLoadNodePath {
const types = await openbis.getDataSetTypes([id], fetchOptions)
const type = types[object.id]
- return this.createTypePath(
+ return this.createNodePath(
object,
type,
objectType.DATA_SET_TYPE,
@@ -84,7 +84,7 @@ export default class TypeBrowserConstsLoadNodePath {
const types = await openbis.getMaterialTypes([id], fetchOptions)
const type = types[object.id]
- return this.createTypePath(
+ return this.createNodePath(
object,
type,
objectType.MATERIAL_TYPE,
@@ -97,7 +97,7 @@ export default class TypeBrowserConstsLoadNodePath {
const types = await openbis.getVocabularies([id], fetchOptions)
const type = types[object.id]
- return this.createTypePath(
+ return this.createNodePath(
object,
type,
objectType.VOCABULARY_TYPE,
@@ -121,7 +121,7 @@ export default class TypeBrowserConstsLoadNodePath {
]
}
- createTypePath(object, type, folderObjectType, folderText) {
+ createNodePath(object, type, folderObjectType, folderText) {
if (type) {
const folderPath = this.createFolderPath(folderObjectType, folderText)
return [
diff --git a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodes.js b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodes.js
new file mode 100644
index 0000000000000000000000000000000000000000..15de855b888e5a7866c72d38340ad9f6a0153c5b
--- /dev/null
+++ b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodes.js
@@ -0,0 +1,311 @@
+import _ from 'lodash'
+import TypeBrowserConsts from '@src/js/components/types/browser2/TypeBrowserConsts.js'
+import openbis from '@src/js/services/openbis.js'
+import objectType from '@src/js/common/consts/objectType.js'
+import messages from '@src/js/common/messages.js'
+import compare from '@src/js/common/compare.js'
+
+const LOAD_LIMIT = 100
+const TOTAL_LOAD_LIMIT = 500
+
+export default class TypeBrowserConstsLoadNodesUnfiltered {
+ async doLoadNodes(params) {
+ const { node } = params
+
+ if (node.internalRoot) {
+ return {
+ nodes: [
+ {
+ id: TypeBrowserConsts.TYPE_ROOT,
+ object: {
+ type: TypeBrowserConsts.TYPE_ROOT
+ },
+ canHaveChildren: true
+ }
+ ]
+ }
+ } else if (node.object.type === TypeBrowserConsts.TYPE_ROOT) {
+ const [
+ objectTypes,
+ collectionTypes,
+ dataSetTypes,
+ materialTypes,
+ vocabularyTypes
+ ] = await Promise.all([
+ this.searchObjectTypes(params),
+ this.searchCollectionTypes(params),
+ this.searchDataSetTypes(params),
+ this.searchMaterialTypes(params),
+ this.searchVocabularyTypes(params)
+ ])
+
+ if (params.filter) {
+ const totalCount =
+ objectTypes.getTotalCount() +
+ collectionTypes.getTotalCount() +
+ dataSetTypes.getTotalCount() +
+ materialTypes.getTotalCount() +
+ vocabularyTypes.getTotalCount()
+
+ if (totalCount > TOTAL_LOAD_LIMIT) {
+ return this.tooManyResultsFound(node)
+ }
+ }
+
+ let nodes = [
+ this.createObjectTypesNode(node, objectTypes),
+ this.createCollectionTypesNode(node, collectionTypes),
+ this.createDataSetTypesNode(node, dataSetTypes),
+ this.createMaterialTypesNode(node, materialTypes),
+ this.createVocabularyTypesNode(node, vocabularyTypes),
+ this.createPropertyTypesNode(node, null)
+ ]
+
+ if (params.filter) {
+ nodes = nodes.filter(node => !_.isEmpty(node.children))
+ }
+
+ return {
+ nodes: nodes
+ }
+ } else if (node.object.type === objectType.OVERVIEW) {
+ let types = null
+
+ if (node.object.id === objectType.OBJECT_TYPE) {
+ types = await this.searchObjectTypes(params)
+ } else if (node.object.id === objectType.COLLECTION_TYPE) {
+ types = await this.searchCollectionTypes(params)
+ } else if (node.object.id === objectType.DATA_SET_TYPE) {
+ types = await this.searchDataSetTypes(params)
+ } else if (node.object.id === objectType.MATERIAL_TYPE) {
+ types = await this.searchMaterialTypes(params)
+ } else if (node.object.id === objectType.VOCABULARY_TYPE) {
+ types = await this.searchVocabularyTypes(params)
+ }
+
+ if (types) {
+ return this.createNodes(node, types, node.object.id)
+ } else {
+ return {
+ nodes: []
+ }
+ }
+ } else {
+ return null
+ }
+ }
+
+ tooManyResultsFound(node) {
+ return {
+ nodes: [
+ {
+ id: TypeBrowserConsts.nodeId(node.id, TypeBrowserConsts.TYPE_WARNING),
+ message: {
+ type: 'warning',
+ text: messages.get(messages.TOO_MANY_FILTERED_RESULTS_FOUND)
+ },
+ selectable: false
+ }
+ ]
+ }
+ }
+
+ async searchObjectTypes(params) {
+ const { filter, offset, limit } = params
+
+ const criteria = new openbis.SampleTypeSearchCriteria()
+ if (filter) {
+ criteria.withCode().thatContains(filter)
+ }
+ const fetchOptions = new openbis.SampleTypeFetchOptions()
+
+ const result = await openbis.searchSampleTypes(criteria, fetchOptions)
+ result.criteria = {
+ filter,
+ offset,
+ limit
+ }
+ return result
+ }
+
+ async searchCollectionTypes(params) {
+ const { filter, offset, limit } = params
+
+ const criteria = new openbis.ExperimentTypeSearchCriteria()
+ if (filter) {
+ criteria.withCode().thatContains(filter)
+ }
+ const fetchOptions = new openbis.ExperimentTypeFetchOptions()
+
+ const result = await openbis.searchExperimentTypes(criteria, fetchOptions)
+ result.criteria = {
+ filter,
+ offset,
+ limit
+ }
+ return result
+ }
+
+ async searchDataSetTypes(params) {
+ const { filter, offset, limit } = params
+
+ const criteria = new openbis.DataSetTypeSearchCriteria()
+ if (filter) {
+ criteria.withCode().thatContains(filter)
+ }
+ const fetchOptions = new openbis.DataSetTypeFetchOptions()
+
+ const result = await openbis.searchDataSetTypes(criteria, fetchOptions)
+ result.criteria = {
+ filter,
+ offset,
+ limit
+ }
+ return result
+ }
+
+ async searchMaterialTypes(params) {
+ const { filter, offset, limit } = params
+
+ const criteria = new openbis.MaterialTypeSearchCriteria()
+ if (filter) {
+ criteria.withCode().thatContains(filter)
+ }
+ const fetchOptions = new openbis.MaterialTypeFetchOptions()
+
+ const result = await openbis.searchMaterialTypes(criteria, fetchOptions)
+ result.criteria = {
+ filter,
+ offset,
+ limit
+ }
+ return result
+ }
+
+ async searchVocabularyTypes(params) {
+ const { filter, offset, limit } = params
+
+ const criteria = new openbis.VocabularySearchCriteria()
+ if (filter) {
+ criteria.withCode().thatContains(filter)
+ }
+ const fetchOptions = new openbis.VocabularyFetchOptions()
+
+ const result = await openbis.searchVocabularies(criteria, fetchOptions)
+ result.criteria = {
+ filter,
+ offset,
+ limit
+ }
+ return result
+ }
+
+ createObjectTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.OBJECT_TYPE,
+ TypeBrowserConsts.TEXT_OBJECT_TYPES
+ )
+ }
+
+ createCollectionTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.COLLECTION_TYPE,
+ TypeBrowserConsts.TEXT_COLLECTION_TYPES
+ )
+ }
+
+ createDataSetTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.DATA_SET_TYPE,
+ TypeBrowserConsts.TEXT_DATA_SET_TYPES
+ )
+ }
+
+ createMaterialTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.MATERIAL_TYPE,
+ TypeBrowserConsts.TEXT_MATERIAL_TYPES
+ )
+ }
+
+ createVocabularyTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.VOCABULARY_TYPE,
+ TypeBrowserConsts.TEXT_VOCABULARY_TYPES
+ )
+ }
+
+ createPropertyTypesNode(parent, result) {
+ return this.createFolderNode(
+ parent,
+ result,
+ objectType.PROPERTY_TYPE,
+ TypeBrowserConsts.TEXT_PROPERTY_TYPES
+ )
+ }
+
+ createFolderNode(parent, result, folderObjectType, folderText) {
+ const folderNode = {
+ id: TypeBrowserConsts.nodeId(parent.id, folderObjectType),
+ text: folderText,
+ object: {
+ type: objectType.OVERVIEW,
+ id: folderObjectType
+ },
+ canHaveChildren: !!result,
+ selectable: true,
+ expanded: true
+ }
+
+ if (result) {
+ folderNode.children = this.createNodes(
+ folderNode,
+ result,
+ folderObjectType
+ )
+ }
+
+ return folderNode
+ }
+
+ createNodes(parent, result, objectType) {
+ const { offset } = result.criteria
+
+ let objects = result.getObjects()
+ objects.sort((o1, o2) => compare(o1.code, o2.code))
+ objects = objects.slice(offset, offset + LOAD_LIMIT)
+
+ let nodes = objects.map(type => ({
+ id: TypeBrowserConsts.nodeId(parent.id, objectType, type.getCode()),
+ text: type.getCode(),
+ object: {
+ type: objectType,
+ id: type.getCode()
+ }
+ }))
+
+ if (_.isEmpty(nodes)) {
+ return null
+ } else {
+ return {
+ nodes: nodes,
+ loadMore: {
+ offset: offset + nodes.length,
+ loadedCount: offset + nodes.length,
+ totalCount: result.getTotalCount(),
+ append: true
+ }
+ }
+ }
+ }
+}
diff --git a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesFiltered.js b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesFiltered.js
deleted file mode 100644
index 68a90958c2b588b40b7711048d5982e703e2e202..0000000000000000000000000000000000000000
--- a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesFiltered.js
+++ /dev/null
@@ -1,282 +0,0 @@
-import _ from 'lodash'
-import TypeBrowserConsts from '@src/js/components/types/browser2/TypeBrowserConsts.js'
-import openbis from '@src/js/services/openbis.js'
-import objectType from '@src/js/common/consts/objectType.js'
-import messages from '@src/js/common/messages.js'
-import compare from '@src/js/common/compare.js'
-
-const LOAD_LIMIT = 50
-const TOTAL_LOAD_LIMIT = 500
-
-export default class TypeBrowserConstsLoadNodesFiltered {
- async doLoadFilteredNodes(params) {
- const { node } = params
-
- const [
- objectTypes,
- collectionTypes,
- dataSetTypes,
- materialTypes,
- vocabularyTypes
- ] = await Promise.all([
- this.searchObjectTypes(params),
- this.searchCollectionTypes(params),
- this.searchDataSetTypes(params),
- this.searchMaterialTypes(params),
- this.searchVocabularyTypes(params)
- ])
-
- const loadedCount =
- objectTypes.getObjects().length +
- collectionTypes.getObjects().length +
- dataSetTypes.getObjects().length +
- materialTypes.getObjects().length +
- vocabularyTypes.getObjects().length
-
- const totalCount =
- objectTypes.getTotalCount() +
- collectionTypes.getTotalCount() +
- dataSetTypes.getTotalCount() +
- materialTypes.getTotalCount() +
- vocabularyTypes.getTotalCount()
-
- if (totalCount > TOTAL_LOAD_LIMIT) {
- return this.tooManyResultsFound(node)
- }
-
- const result = {
- nodes: [],
- loadMore: {
- offset: 0,
- limit: TOTAL_LOAD_LIMIT,
- loadedCount: loadedCount,
- totalCount: totalCount,
- append: false
- }
- }
-
- if (node.internalRoot) {
- const root = {
- id: TypeBrowserConsts.TYPE_ROOT,
- object: {
- type: TypeBrowserConsts.TYPE_ROOT
- },
- canHaveChildren: true
- }
- root.children = this.doLoadFilteredNodes({
- ...params,
- node: root
- })
- result.nodes.push(root)
- } else if (node.object.type === TypeBrowserConsts.TYPE_ROOT) {
- if (!_.isEmpty(objectTypes.getObjects())) {
- const objectTypesNode = this.createObjectTypesNode(
- params,
- objectTypes.getObjects()
- )
- result.nodes.push(objectTypesNode)
- }
- if (!_.isEmpty(collectionTypes.getObjects())) {
- const collectionTypesNode = this.createCollectionTypesNode(
- params,
- collectionTypes.getObjects()
- )
- result.nodes.push(collectionTypesNode)
- }
- if (!_.isEmpty(dataSetTypes.getObjects())) {
- const dataSetTypesNode = this.createDataSetTypesNode(
- params,
- dataSetTypes.getObjects()
- )
- result.nodes.push(dataSetTypesNode)
- }
- if (!_.isEmpty(materialTypes.getObjects())) {
- const materialTypesNode = this.createMaterialTypesNode(
- params,
- materialTypes.getObjects()
- )
- result.nodes.push(materialTypesNode)
- }
- if (!_.isEmpty(vocabularyTypes.getObjects())) {
- const vocabularyTypesNode = this.createVocabularyTypesNode(
- params,
- vocabularyTypes.getObjects()
- )
- result.nodes.push(vocabularyTypesNode)
- }
- }
-
- return result
- }
-
- tooManyResultsFound(node) {
- return {
- nodes: [
- {
- id: TypeBrowserConsts.nodeId(node.id, TypeBrowserConsts.TYPE_WARNING),
- message: {
- type: 'warning',
- text: messages.get(messages.TOO_MANY_FILTERED_RESULTS_FOUND)
- },
- selectable: false
- }
- ]
- }
- }
-
- async searchObjectTypes(params) {
- const { filter, offset, limit } = params
-
- const criteria = new openbis.SampleTypeSearchCriteria()
- criteria.withCode().thatContains(filter)
-
- const fetchOptions = new openbis.SampleTypeFetchOptions()
- fetchOptions.from(offset)
- fetchOptions.count(limit || LOAD_LIMIT)
-
- const result = await openbis.searchSampleTypes(criteria, fetchOptions)
-
- return result
- }
-
- async searchCollectionTypes(params) {
- const { filter, offset, limit } = params
-
- const criteria = new openbis.ExperimentTypeSearchCriteria()
- criteria.withCode().thatContains(filter)
-
- const fetchOptions = new openbis.ExperimentTypeFetchOptions()
- fetchOptions.from(offset)
- fetchOptions.count(limit || LOAD_LIMIT)
-
- const result = await openbis.searchExperimentTypes(criteria, fetchOptions)
-
- return result
- }
-
- async searchDataSetTypes(params) {
- const { filter, offset, limit } = params
-
- const criteria = new openbis.DataSetTypeSearchCriteria()
- criteria.withCode().thatContains(filter)
-
- const fetchOptions = new openbis.DataSetTypeFetchOptions()
- fetchOptions.from(offset)
- fetchOptions.count(limit || LOAD_LIMIT)
-
- const result = await openbis.searchDataSetTypes(criteria, fetchOptions)
-
- return result
- }
-
- async searchMaterialTypes(params) {
- const { filter, offset, limit } = params
-
- const criteria = new openbis.MaterialTypeSearchCriteria()
- criteria.withCode().thatContains(filter)
-
- const fetchOptions = new openbis.MaterialTypeFetchOptions()
- fetchOptions.from(offset)
- fetchOptions.count(limit || LOAD_LIMIT)
-
- const result = await openbis.searchMaterialTypes(criteria, fetchOptions)
-
- return result
- }
-
- async searchVocabularyTypes(params) {
- const { filter, offset, limit } = params
-
- const criteria = new openbis.VocabularySearchCriteria()
- criteria.withCode().thatContains(filter)
-
- const fetchOptions = new openbis.VocabularyFetchOptions()
- fetchOptions.from(offset)
- fetchOptions.count(limit || LOAD_LIMIT)
-
- const result = await openbis.searchVocabularies(criteria, fetchOptions)
-
- return result
- }
-
- createObjectTypesNode(params, types) {
- return this.createNodesFolder(
- params,
- types,
- objectType.OBJECT_TYPE,
- TypeBrowserConsts.TEXT_OBJECT_TYPES
- )
- }
-
- createCollectionTypesNode(params, types) {
- return this.createNodesFolder(
- params,
- types,
- objectType.COLLECTION_TYPE,
- TypeBrowserConsts.TEXT_COLLECTION_TYPES
- )
- }
-
- createDataSetTypesNode(params, types) {
- return this.createNodesFolder(
- params,
- types,
- objectType.DATA_SET_TYPE,
- TypeBrowserConsts.TEXT_DATA_SET_TYPES
- )
- }
-
- createMaterialTypesNode(params, types) {
- return this.createNodesFolder(
- params,
- types,
- objectType.MATERIAL_TYPE,
- TypeBrowserConsts.TEXT_MATERIAL_TYPES
- )
- }
-
- createVocabularyTypesNode(params, types) {
- return this.createNodesFolder(
- params,
- types,
- objectType.VOCABULARY_TYPE,
- TypeBrowserConsts.TEXT_VOCABULARY_TYPES
- )
- }
-
- createNodesFolder(params, types, folderObjectType, folderText) {
- const { node } = params
-
- const folderNode = {
- id: TypeBrowserConsts.nodeId(node.id, folderObjectType),
- text: folderText,
- object: {
- type: objectType.OVERVIEW,
- id: folderObjectType
- },
- canHaveChildren: true,
- children: { nodes: [] },
- expanded: true
- }
-
- types.sort((o1, o2) => compare(o1.code, o2.code))
-
- types.forEach(type => {
- const typeNode = {
- id: TypeBrowserConsts.nodeId(
- folderNode.id,
- folderObjectType,
- type.code
- ),
- text: type.code,
- object: {
- type: folderObjectType,
- id: type.code
- }
- }
- folderNode.children.nodes.push(typeNode)
- })
-
- return folderNode
- }
-}
diff --git a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesUnfiltered.js b/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesUnfiltered.js
deleted file mode 100644
index c8f8a1f11f0aa4132d65272f7b5d31ebc296f5c8..0000000000000000000000000000000000000000
--- a/openbis_ng_ui/src/js/components/types/browser2/TypeBrowserControllerLoadNodesUnfiltered.js
+++ /dev/null
@@ -1,231 +0,0 @@
-import _ from 'lodash'
-import TypeBrowserConsts from '@src/js/components/types/browser2/TypeBrowserConsts.js'
-import openbis from '@src/js/services/openbis.js'
-import objectType from '@src/js/common/consts/objectType.js'
-import compare from '@src/js/common/compare.js'
-
-const LOAD_LIMIT = 50
-
-export default class TypeBrowserConstsLoadNodesUnfiltered {
- async doLoadUnfilteredNodes(params) {
- const { node } = params
-
- if (node.internalRoot) {
- return {
- nodes: [
- {
- id: TypeBrowserConsts.TYPE_ROOT,
- object: {
- type: TypeBrowserConsts.TYPE_ROOT
- },
- canHaveChildren: true
- }
- ]
- }
- } else if (node.object.type === TypeBrowserConsts.TYPE_ROOT) {
- const nodes = []
-
- await this.addObjectTypesNode(params, nodes)
- await this.addCollectionTypesNode(params, nodes)
- await this.addDataSetTypesNode(params, nodes)
- await this.addMaterialTypesNode(params, nodes)
- await this.addVocabularyTypesNode(params, nodes)
- await this.addPropertyTypesNode(params, nodes)
-
- return {
- nodes: nodes
- }
- } else if (node.object.type === objectType.OVERVIEW) {
- if (node.object.id === objectType.OBJECT_TYPE) {
- return await this.searchObjectTypes(params)
- } else if (node.object.id === objectType.COLLECTION_TYPE) {
- return await this.searchCollectionTypes(params)
- } else if (node.object.id === objectType.DATA_SET_TYPE) {
- return await this.searchDataSetTypes(params)
- } else if (node.object.id === objectType.MATERIAL_TYPE) {
- return await this.searchMaterialTypes(params)
- } else if (node.object.id === objectType.VOCABULARY_TYPE) {
- return await this.searchVocabularyTypes(params)
- } else if (node.object.id === objectType.PROPERTY_TYPE) {
- return await this.searchPropertyTypes(params)
- }
- } else {
- return null
- }
- }
-
- async searchObjectTypes(params) {
- const criteria = new openbis.SampleTypeSearchCriteria()
- const fetchOptions = new openbis.SampleTypeFetchOptions()
-
- const result = await openbis.searchSampleTypes(criteria, fetchOptions)
-
- return this.createNodes(params, objectType.OBJECT_TYPE, result)
- }
-
- async searchCollectionTypes(params) {
- const criteria = new openbis.ExperimentTypeSearchCriteria()
- const fetchOptions = new openbis.ExperimentTypeFetchOptions()
-
- const result = await openbis.searchExperimentTypes(criteria, fetchOptions)
-
- return this.createNodes(params, objectType.COLLECTION_TYPE, result)
- }
-
- async searchDataSetTypes(params) {
- const criteria = new openbis.DataSetTypeSearchCriteria()
- const fetchOptions = new openbis.DataSetTypeFetchOptions()
-
- const result = await openbis.searchDataSetTypes(criteria, fetchOptions)
-
- return this.createNodes(params, objectType.DATA_SET_TYPE, result)
- }
-
- async searchMaterialTypes(params) {
- const criteria = new openbis.MaterialTypeSearchCriteria()
- const fetchOptions = new openbis.MaterialTypeFetchOptions()
-
- const result = await openbis.searchMaterialTypes(criteria, fetchOptions)
-
- return this.createNodes(params, objectType.MATERIAL_TYPE, result)
- }
-
- async searchVocabularyTypes(params) {
- const criteria = new openbis.VocabularySearchCriteria()
- const fetchOptions = new openbis.VocabularyFetchOptions()
-
- const result = await openbis.searchVocabularies(criteria, fetchOptions)
-
- return this.createNodes(params, objectType.VOCABULARY_TYPE, result)
- }
-
- async addObjectTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.OBJECT_TYPE,
- TypeBrowserConsts.TEXT_OBJECT_TYPES,
- this.searchObjectTypes.bind(this)
- )
- if (folderNode) {
- nodes.push(folderNode)
- }
- }
-
- async addCollectionTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.COLLECTION_TYPE,
- TypeBrowserConsts.TEXT_COLLECTION_TYPES,
- this.searchCollectionTypes.bind(this)
- )
- if (folderNode) {
- nodes.push(folderNode)
- }
- }
-
- async addDataSetTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.DATA_SET_TYPE,
- TypeBrowserConsts.TEXT_DATA_SET_TYPES,
- this.searchDataSetTypes.bind(this)
- )
- if (folderNode) {
- nodes.push(folderNode)
- }
- }
-
- async addMaterialTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.MATERIAL_TYPE,
- TypeBrowserConsts.TEXT_MATERIAL_TYPES,
- this.searchMaterialTypes.bind(this)
- )
- if (folderNode) {
- nodes.push(folderNode)
- }
- }
-
- async addVocabularyTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.VOCABULARY_TYPE,
- TypeBrowserConsts.TEXT_VOCABULARY_TYPES,
- this.searchVocabularyTypes.bind(this)
- )
- if (folderNode) {
- nodes.push(folderNode)
- }
- }
-
- async addPropertyTypesNode(params, nodes) {
- const folderNode = await this.createNodesFolder(
- params,
- objectType.PROPERTY_TYPE,
- TypeBrowserConsts.TEXT_PROPERTY_TYPES,
- () => []
- )
- if (folderNode) {
- folderNode.canHaveChildren = false
- nodes.push(folderNode)
- }
- }
-
- createNodes(params, objectType, result) {
- const { node, offset } = params
-
- let nodes = result.getObjects().map(type => ({
- id: TypeBrowserConsts.nodeId(node.id, objectType, type.getCode()),
- text: type.getCode(),
- object: {
- type: objectType,
- id: type.getCode()
- }
- }))
-
- nodes.sort((n1, n2) => compare(n1.text, n2.text))
- nodes = nodes.slice(offset, offset + LOAD_LIMIT)
-
- if (_.isEmpty(nodes)) {
- return null
- } else {
- return {
- nodes: nodes,
- loadMore: {
- offset: offset + nodes.length,
- loadedCount: offset + nodes.length,
- totalCount: result.getTotalCount(),
- append: offset > 0
- }
- }
- }
- }
-
- async createNodesFolder(params, folderObjectType, folderText, search) {
- const { node } = params
-
- const folderNode = {
- id: TypeBrowserConsts.nodeId(node.id, folderObjectType),
- text: folderText,
- object: {
- type: objectType.OVERVIEW,
- id: folderObjectType
- },
- canHaveChildren: true,
- selectable: true
- }
-
- const nodes = await search({
- ...params,
- node: folderNode
- })
-
- if (nodes) {
- folderNode.children = nodes
- return folderNode
- } else {
- return null
- }
- }
-}