routes

# ----------------------------------------------------------------------
# ROUTES
# This file defines all application routes (Higher priority routes first)
# ----------------------------------------------------------------------

#make this the first rule

#OPTIONS       /*path                                                                   @controllers.Application.options(path)
OPTIONS        /*path                                                                   api.ApiHelp.options(path)

# operations are applied in this order, to prevent untrail from removing
# the trailing / at the end of the /api/proxy calls it is placed before
# the untrail call
GET            /api/proxy/:endpoint_key                                                 @api.Proxy.get(endpoint_key: String, pathSuffix: String = null)
GET            /api/proxy/:endpoint_key/                                                @api.Proxy.get(endpoint_key: String, pathSuffix: String = "")
GET            /api/proxy/:endpoint_key/*pathSuffix                                     @api.Proxy.get(endpoint_key: String, pathSuffix: String)
GET            /*path/                                                                  @controllers.Application.untrail(path: String)

# ----------------------------------------------------------------------
# HOME PAGE
# ----------------------------------------------------------------------

GET            /                                                                        @controllers.Application.index
GET            /about                                                                   @controllers.Application.about
GET            /tos                                                                     @controllers.Application.tos(redirect: Option[String] ?= None)
GET            /email                                                                   @controllers.Application.email(subject: String ?= "", body: String ?= "")
GET            /healthz                                                                 @controllers.Application.healthz()

# ----------------------------------------------------------------------
# Map static resources from the /public folder to the /assets URL path
# ----------------------------------------------------------------------
GET            /contexts/metadata.jsonld                                                controllers.Assets.at(path="/public", file="/jsonld/contexts/metadata.jsonld")
GET            /assets/img/glyphicons-halflings-white.png                               controllers.Assets.at(path="/public", file="/images/glyphicons-halflings-white.png")
GET            /assets/img/glyphicons-halflings.png                                     controllers.Assets.at(path="/public", file="/images/glyphicons-halflings.png")
GET            /assets/*file                                                            controllers.Assets.at(path="/public", file)

# ----------------------------------------------------------------------
# USERS
# ----------------------------------------------------------------------
GET            /users                                                                   @controllers.Users.getUsers(when: String ?= "", id: String ?= "", limit: Int ?=24)
GET            /users/acceptTermsOfServices                                             @controllers.Users.acceptTermsOfServices(redirect: Option[String] ?= None)
GET            /login/isLoggedIn                                                        @controllers.Login.isLoggedIn
POST           /users/sendEmail                                                         @controllers.Users.sendEmail(subject: String, from: String, recipient: String, body: String)
GET            /ldap                                                                    @controllers.Login.ldap(redirecturl:String, token:String)
POST           /ldap/authenticate                                                       @controllers.Login.ldapAuthenticate(uid: String, password: String)
# ----------------------------------------------------------------------
# PROFILE
# ----------------------------------------------------------------------
# deprecated use profile/:uuid
GET            /profile/viewProfile                                                     @controllers.Profile.viewProfile(email: Option[String])
# deprecated use profile/:uuid
GET            /profile/viewProfile/:uuid                                               @controllers.Profile.viewProfileUUID(uuid: UUID)
GET            /profile/editProfile                                                     @controllers.Profile.editProfile
POST           /profile/submitChanges                                                   @controllers.Profile.submitChanges
GET            /profile/:uuid                                                           @controllers.Profile.viewProfileUUID(uuid: UUID)

# ----------------------------------------------------------------------
# ERRORS
# ----------------------------------------------------------------------
GET            /error/authenticationRequired                                            @controllers.Error.authenticationRequired
GET            /error/authenticationRequiredMessage/:msg/:url                           @controllers.Error.authenticationRequiredMessage(msg, url)
GET            /error/noPermissions                                                     @controllers.Error.incorrectPermissions(msg ?= null)
GET            /error/notActivated                                                      @controllers.Error.notActivated
GET            /error/notAuthorized                                                     @controllers.Error.notAuthorized(msg:String,  id:String, resourceType:String )

# ----------------------------------------------------------------------
# DTS INFORMATION
# ----------------------------------------------------------------------
GET            /extractions/requests                                                    @controllers.ExtractionInfo.getDTSRequests()
GET            /extractions/servers_ips                                                 @controllers.ExtractionInfo.getExtractorServersIP()
GET            /extractions/extractors_names                                            @controllers.ExtractionInfo.getExtractorNames()
GET            /extractions/supported_input_types                                       @controllers.ExtractionInfo.getExtractorInputTypes()

# ----------------------------------------------------------------------
# DTS BOOKMARKLET
# ----------------------------------------------------------------------v
GET            /bookmarklet                                                             @controllers.ExtractionInfo.getBookmarkletPage()
GET            /bookmarklet.js                                                          @controllers.Application.bookmarklet

# ----------------------------------------------------------------------
# DTS CHROME EXTENSIONS
# ----------------------------------------------------------------------
GET            /extensions/dts/chrome                                                   @controllers.ExtractionInfo.getExtensionPage()
#This may not require; This is only for testing. It will change in subsequent version
GET            /extraction/form                                                         @controllers.Files.extractFile
POST           /extraction/upload                                                       @controllers.Files.uploadExtract()
#End

# ----------------------------------------------------------------------
# FILES
# ----------------------------------------------------------------------
GET            /files                                                                   @controllers.Files.list(when: String ?= "", date: String ?= "", size: Int ?= 12, mode: String ?= "")
GET            /files/new                                                               @controllers.Files.uploadFile
GET            /files/metadataSearch                                                    @controllers.Files.metadataSearch
GET            /files/generalMetadataSearch                                             @controllers.Files.generalMetadataSearch
GET            /files/following                                                         @controllers.Files.followingFiles(index: Int ?= 0, size: Int ?= 12, mode: String ?= "")
GET            /files/:id                                                               @controllers.Files.file(id: UUID, dataset: Option[String] ?= None, space: Option[String] ?= None, folder: Option[String] ?= None)
GET            /files/:id/blob                                                          @controllers.Files.download(id: UUID)
GET            /files/:id/download/:format                                              @controllers.Files.downloadAsFormat(id: UUID, format: String)
#GET           /queries/:id/blob				                                        @controllers.Files.downloadquery(id: UUID)
#GET           /files/:id/similar                                                       @controllers.Files.findSimilar(id: UUID)
POST           /upload                                                                  @controllers.Files.upload
POST           /uploadSelectQuery                                                       @controllers.Files.uploadSelectQuery
#POST          /uploadAjax					                                            @controllers.Files.uploadAjax
POST           /uploaddnd/:id                                                           @controllers.Files.uploaddnd(id: UUID)
#POST  	       /reactiveUpload					                                        @controllers.Files.reactiveUpload
POST           /uploadDragDrop                                                          @controllers.Files.uploadDragDrop
# deprecrated use thumbnails
GET            /fileThumbnail/:id/blob                                                  @controllers.Files.thumbnail(id: UUID)
GET            /file_by_section/:id                                                     @controllers.Files.fileBySection(id: UUID)
GET            /files/:file_id/extractions                                              @controllers.Extractors.submitFileExtraction(file_id: UUID)

# ----------
# File Links
# ----------
GET            /files/:fileId/share                                                     @controllers.FileLinks.share(fileId: UUID)
GET            /files/links/:linkId                                                     @controllers.FileLinks.download(linkId: UUID)
POST           /files/:fileId/links                                                     @controllers.FileLinks.createLink(fileId: UUID)

# ----------------------------------------------------------------------
# DATASETS
# ----------------------------------------------------------------------
GET            /datasets                                                                @controllers.Datasets.list(when: String ?= "", date: String ?= "", size: Int ?= 12, space: Option[String] ?= None, status: Option[String] ?= None, mode: String ?= "", owner: Option[String] ?= None, showPublic: Boolean ?= true, showOnlyShared : Boolean ?= false, showTrash : Boolean ?= false)
GET            /datasets/sorted                                                         @controllers.Datasets.sortedListInSpace(space: String, offset: Int ?= 0, size: Int ?= 12, showPublic: Boolean ?= true)
GET            /datasets/new                                                            @controllers.Datasets.newDataset(space: Option[String], collection: Option[String])
GET            /datasets/createStep2                                                    @controllers.Datasets.createStep2(id: UUID)
GET            /datasets/metadataSearch                                                 @controllers.Datasets.metadataSearch
GET            /datasets/generalMetadataSearch                                          @controllers.Datasets.generalMetadataSearch
GET            /datasets/following                                                      @controllers.Datasets.followingDatasets(index: Int ?= 0, size: Int ?= 12, mode: String ?= "")
GET            /toolManager                                                             @controllers.ToolManager.toolManager
GET            /datasets/refreshToolList                                                @controllers.ToolManager.refreshToolSidebar(datasetid: UUID, datasetName: String)
GET            /datasets/launchableTools                                                @controllers.ToolManager.getLaunchableTools
GET            /datasets/uploadToTool                                                   @controllers.ToolManager.uploadDatasetToTool(instanceID: UUID, datasetID: UUID, datasetName: String)
GET            /datasets/getInstances                                                   @controllers.ToolManager.getInstances
GET            /datasets/removeInstance                                                 @controllers.ToolManager.removeInstance(toolType: String, instanceID: UUID)
GET            /datasets/launchTool                                                     @controllers.ToolManager.launchTool(sessionName: String, ttype: String, datasetId: UUID, datasetName: String)
GET            /datasets/:id                                                            @controllers.Datasets.dataset(id: UUID, space: Option[String] ?= None, limit: Int ?= 20, filter: Option[String] ?= None)
POST           /datasets/:datasetId/updatedFilesAndFolders                              @controllers.Datasets.getUpdatedFilesAndFolders(datasetId: UUID, limit: Int ?= 20, pageIndex: Int ?= 0, space: Option[String]?= None, filter: Option[String]?=None)
GET            /datasets/:id/users                                                      @controllers.Datasets.users(id: UUID)
GET            /datasets_by_section/:id                                                 @controllers.Datasets.datasetBySection(id: UUID)
POST           /dataset/submit                                                          @controllers.Datasets.submit(folderId: Option[String] ?= None)
GET            /datasets/:id/addFiles                                                   @controllers.Datasets.addFiles(id: UUID)
GET            /datasets/:id/:folderId/addFiles                                         @controllers.Folders.addFiles(id: UUID, folderId: String)
POST           /datasets/:parentDatasetId/newFolder                                     @controllers.Folders.createFolder(parentDatasetId: UUID)
GET            /datasets/:id/extractions                                                @controllers.Extractors.submitDatasetExtraction(id: UUID)

# ----------------------------------------------------------------------
# COLLECTIONS
# ----------------------------------------------------------------------
GET            /collections                                                             @controllers.Collections.list(when: String ?= "", date: String ?= "", size: Int ?= 12, space: Option[String] ?= None, mode: String ?= "", owner: Option[String] ?= None, showPublic: Boolean ?= true, showOnlyShared : Boolean ?= false, showTrash : Boolean ?= false)
GET            /collections/sorted                                                      @controllers.Collections.sortedListInSpace(space: String,offset: Integer, limit:Integer,  showPublic: Boolean ?= true)
GET            /collections/listChildCollections                                        @controllers.Collections.listChildCollections(parentCollectionId : String, when: String ?= "", date: String ?= "", size: Int ?= 12,  space: Option[String] ?= None, mode: String ?= "", owner: Option[String] ?= None)
GET            /collections/new                                                         @controllers.Collections.newCollection(space: Option[String])
GET            /collections/:id/newchildCollection                                      @controllers.Collections.newCollectionWithParent(id: UUID)
GET            /collections/following                                                   @controllers.Collections.followingCollections(index: Int ?= 0, size: Int ?= 12, mode: String ?= "")
POST           /collection/submit                                                       @controllers.Collections.submit
GET            /collection/:id                                                          @controllers.Collections.collection(id: UUID, limit: Int ?= 12)
GET            /collection/:id/users                                                    @controllers.Collections.users(id: UUID)
GET            /collections/:collection_id/previews                                     @controllers.Collections.previews(collection_id: UUID)
GET            /collection/:id/datasets                                                 @controllers.Collections.getUpdatedDatasets(id:UUID, index: Int?=0, limit: Int?= 12)
GET            /collection/:id/childCollections                                         @controllers.Collections.getUpdatedChildCollections(id:UUID, index: Int?=0, limit: Int ?=12)
# ----------------------------------------------------------------------
# Spaces
# ----------------------------------------------------------------------
GET            /spaces                                                                  @controllers.Spaces.list(when: String ?= "", date: String ?= "", size: Int ?= 12, mode: String ?= "", owner: Option[String] ?= None, showAll: Boolean ?= true, showPublic: Boolean ?= true, onlyTrial: Boolean ?=false, showOnlyShared : Boolean ?= false)
GET            /spaces/new                                                              @controllers.Spaces.newSpace
GET            /spaces/following                                                        @controllers.Spaces.followingSpaces(index: Int ?=0, size: Int ?= 12, mode: String ?= "")
GET            /spaces/:id                                                              @controllers.Spaces.getSpace(id: UUID, size: Int ?= 9, direction: String ?= "desc")
GET            /spaces/:id/updateSpace                                                  @controllers.Spaces.updateSpace(id:UUID)
GET            /spaces/:id/addRequest                                                   @controllers.Spaces.addRequest(id:UUID)
GET            /spaces/:id/users                                                        @controllers.Spaces.manageUsers(id: UUID)
GET            /spaces/:id/extractors                                                   @controllers.Spaces.selectExtractors(id: UUID)
POST           /spaces/:id/extractors                                                   @controllers.Spaces.updateExtractors(id: UUID)
POST           /spaces/:id/invite                                                       @controllers.Spaces.inviteToSpace(id: UUID)
GET            /spaces/:id/metadata                                                     @controllers.Metadata.getMetadataBySpace(id: UUID)
POST           /spaces/submit                                                           @controllers.Spaces.submit


# ----------------------------------------------------------------------
# EXTRACTORS
# ----------------------------------------------------------------------
GET            /extractors/labels                                                       @controllers.Extractors.manageLabels()
GET            /extractors/:extractorName                                               @controllers.Extractors.showExtractorInfo(extractorName)
GET            /extractors/:extractorName/metrics                                       @controllers.Extractors.showExtractorMetrics(extractorName)
GET            /extractors/:extractorName/logs                                          @controllers.Extractors.showExtractorLog(extractorName)
GET            /extractors/:extractorName/history                                       @controllers.Extractors.showJobHistory(extractorName, extractor_key: Option[String] ?= None)


# ----------------------------------------------------------------------
# SENSORS
# ----------------------------------------------------------------------
GET            /geostreams                                                              @controllers.Geostreams.map
GET            /geostreams/sensors                                                      @controllers.Geostreams.list
GET            /geostreams/sensors/new                                                  @controllers.Geostreams.newSensor
GET            /geostreams/sensors/:id                                                  @controllers.Geostreams.edit(id)

# ----------------------------------------------------------------------
# JSON-LD Metadata
# ----------------------------------------------------------------------
GET            /metadata/search                                                         @controllers.Metadata.search()
GET            /metadata/:id                                                            @controllers.Metadata.view(id: UUID)
GET            /files/:file_id/metadata                                                 @controllers.Metadata.file(file_id: UUID)
GET            /datasets/:dataset_id/metadata                                           @controllers.Metadata.dataset(dataset_id: UUID)
# Tags
GET            /tags/list/ordered                                                       @controllers.Tags.tagListOrdered
GET            /tags/list/weighted                                                      @controllers.Tags.tagListWeighted

# ----------------------------------------------------------------------
#
# ----------------------------------------------------------------------
GET            /search                                                                  @controllers.Search.search(query: String ?= "")
GET            /multimediasearch                                                        @controllers.Search.multimediasearch
#GET           /multimediaserach1                                                       @controllers.Search.multimediasearch1(f, id: UUID)
GET            /advanced                                                                @controllers.Search.advanced
GET            /SearchByText                                                            @controllers.Search.SearchByText(query: String ?= "")
POST           /uploadquery                                                             @controllers.Search.uploadquery
GET            /searchbyURL                                                             @controllers.Search.searchbyURL(query:String?="")
GET            /searchbyfeature/:section_id                                             @controllers.Search.callSearchMultimediaIndexView(section_id: UUID)
GET            /files/:id/similar                                                       @controllers.Search.findSimilarToExistingFile(id: UUID)
GET            /queries/:id/similar                                                     @controllers.Search.findSimilarToQueryFile(id: UUID, typeToSearch:String, sectionsSelected:List[String] ?= List.empty )
POST           /queries/similarWeightedIndexes                                          @controllers.Search.findSimilarWeightedIndexes()

# ----------------------------------------------------------------------
# PREVIEWERS
# ----------------------------------------------------------------------
GET            /previewers/list                                                         controllers.Previewers.list

# ----------------------------------------------------------------------
# SECURE SOCIAL
# ----------------------------------------------------------------------
# ----------------------------------------------------------------------
# LOGIN PAGES
# ----------------------------------------------------------------------
GET            /login                                                                   securesocial.controllers.LoginPage.login
GET            /logout                                                                  securesocial.controllers.LoginPage.logout

# ----------------------------------------------------------------------
# USER REGISTRATION
# ----------------------------------------------------------------------
GET            /signup                                                                  securesocial.controllers.Registration.startSignUp
POST           /signup                                                                  securesocial.controllers.Registration.handleStartSignUp
GET            /signup/:token                                                           securesocial.controllers.Registration.signUp(token)
POST           /signup/:token                                                           @controllers.Registration.handleSignUp(token)
GET            /signupInvite/:token                                                     @controllers.Registration.signUp(token)
GET            /reset                                                                   securesocial.controllers.Registration.startResetPassword
POST           /reset                                                                   securesocial.controllers.Registration.handleStartResetPassword
GET            /reset/:token                                                            securesocial.controllers.Registration.resetPassword(token)
POST           /reset/:token                                                            securesocial.controllers.Registration.handleResetPassword(token)
GET            /password                                                                securesocial.controllers.PasswordChange.page
POST           /password                                                                securesocial.controllers.PasswordChange.handlePasswordChange

# ----------------------------------------------------------------------
# PROVIDERS ENTRY POINTS
# ----------------------------------------------------------------------
GET            /authenticate/:provider                                                  securesocial.controllers.ProviderController.authenticate(provider)
POST           /authenticate/:provider                                                  securesocial.controllers.ProviderController.authenticateByPost(provider)

GET            /not-authorized                                                          securesocial.controllers.ProviderController.notAuthorized

# ----------------------------------------------------------------------
# ADMIN PAGES
# ----------------------------------------------------------------------
GET            /admin/customize                                                         @controllers.Admin.customize
GET            /admin/tos                                                               @controllers.Admin.tos
GET            /admin/users                                                             @controllers.Admin.users
GET            /admin/indexAdmin                                                        @controllers.Admin.adminIndex
GET            /admin/reindexFiles                                                      @controllers.Admin.reindexFiles
GET            /admin/adapters                                                          @controllers.Admin.getAdapters
GET            /admin/extractors                                                        @controllers.Admin.getExtractors
GET            /admin/measures                                                          @controllers.Admin.getMeasures
GET            /admin/indexers                                                          @controllers.Admin.getIndexers
GET            /admin/indexes                                                           @controllers.Admin.getIndexes
GET            /admin/sections                                                          @controllers.Admin.getSections
GET            /admin/metadata/definitions                                              @controllers.Admin.getMetadataDefinitions
POST           /admin/createIndex                                                       @controllers.Admin.createIndex
POST           /admin/index/:id/build                                                   @controllers.Admin.buildIndex(id:String)
DELETE         /admin/index/:id                                                         @controllers.Admin.deleteIndex(id:String)
DELETE         /admin/index                                                             @controllers.Admin.deleteAllIndexes
GET            /admin/roles                                                             @controllers.Admin.listRoles
GET            /admin/roles/new                                                         @controllers.Admin.createRole
POST           /admin/roles/submitNew                                                   @controllers.Admin.submitCreateRole
DELETE         /admin/roles/delete/:id                                                  @controllers.Admin.removeRole(id: UUID)
GET            /admin/roles/:id/edit                                                    @controllers.Admin.editRole(id: UUID)
POST           /admin/roles/update                                                      @controllers.Admin.updateRole
GET            /admin/extractions                                                       @controllers.Extractors.listAllExtractions
GET            /admin/dataDumps                                                         @controllers.Admin.viewDumpers
GET            /admin/sensors                                                           @controllers.Admin.sensors
POST           /api/sensors/config                                                      @api.Admin.sensorsConfig

# ----------------------------------------------------------------------
# JAVASCRIPT ENDPOINTS
# ----------------------------------------------------------------------
GET            /javascriptRoutes                                                        @controllers.Application.javascriptRoutes

# ----------------------------------------------------------------------
# API DOCUMENTATION USING SWAGGER
# ----------------------------------------------------------------------
GET            /swagger                                                                 @controllers.Application.swagger
GET            /swaggerUI                                                               @controllers.Application.swaggerUI

# ----------------------------------------------------------------------
# RESTful API
# ----------------------------------------------------------------------

#----------------------------------------------------------------------
# ADMIN
#----------------------------------------------------------------------
POST           /api/admin/mail                                                          @api.Admin.mail
POST           /api/admin/users                                                         @api.Admin.users
POST           /api/sensors/config                                                      @api.Admin.sensorsConfig
POST           /api/changeAppearance                                                    @api.Admin.submitAppearance
POST           /api/reindex                                                             @api.Admin.reindex
POST           /api/deleteindex                                                         @api.Admin.deleteIndex
POST           /api/admin/configuration                                                 @api.Admin.updateConfiguration

#----------------------------------------------------------------------
# JSON-LD METADATA
#----------------------------------------------------------------------
POST           /api/contexts                                                            @api.ContextLD.addContext()
GET            /api/contexts/:id                                                        @api.ContextLD.getContextById(id: UUID)
GET            /api/contexts/:name/context.json                                         @api.ContextLD.getContextByName(name: String)
DELETE         /api/contexts/:id                                                        @api.ContextLD.removeById(id: UUID)

POST           /api/datasets/:id/metadata.jsonld                                        @api.Datasets.addMetadataJsonLD(id: UUID)
GET            /api/datasets/:id/metadata.jsonld                                        @api.Datasets.getMetadataJsonLD(id: UUID, extractor: Option[String] ?= None)
DELETE         /api/datasets/:id/metadata.jsonld                                        @api.Datasets.removeMetadataJsonLD(id: UUID, extractor: Option[String] ?= None)
POST           /api/files/:id/metadata.jsonld                                           @api.Files.addMetadataJsonLD(id: UUID)
GET            /api/files/:id/metadata.jsonld                                           @api.Files.getMetadataJsonLD(id: UUID, extractor: Option[String] ?= None)
DELETE         /api/files/:id/metadata.jsonld                                           @api.Files.removeMetadataJsonLD(id: UUID, extractor: Option[String] ?= None)
POST           /api/files/metadata.jsonld                                               @api.Files.addBatchMetadataJsonLD()
GET            /api/files/metadata.jsonld                                               @api.Files.getBatchMetadataJsonLD()



POST           /api/metadata.jsonld                                                     @api.Metadata.addUserMetadata()
DELETE         /api/metadata.jsonld/:id                                                 @api.Metadata.removeMetadata(id:UUID)

#GET            /api/metadata.jsonld                                                     @api.Metadata.getUserMetadata()

GET            /api/metadata/definition/:id                                             @api.Metadata.getMetadataDefinition(id: UUID)
GET            /api/metadata/definitions                                                @api.Metadata.getDefinitions()
GET            /api/metadata/distinctdefinitions                                        @api.Metadata.getDefinitionsDistinctName()
GET            /api/metadata/autocompletenames                                          @api.Metadata.getAutocompleteName(filter: String)
GET            /api/metadata/definitions/:id                                            @api.Metadata.getDefinition(id: UUID)
GET            /api/metadata/url/*in_url                                                @api.Metadata.getUrl(in_url: String)
PUT            /api/metadata/definitions/:id                                            @api.Metadata.editDefinition(id:UUID, spaceId: Option[String] ?= None)
POST           /api/metadata/definitions                                                @api.Metadata.addDefinition()
DELETE         /admin/metadata/definitions/:id                                          @api.Metadata.deleteDefinition(id: UUID)

GET            /api/metadata/people		                                        		@api.Metadata.listPeople(term: String, limit:Int)
GET            /api/metadata/people/:pid 		                                        @api.Metadata.getPerson(pid: String)

GET            /api/metadata/repository/:id 		                                    @api.Metadata.getRepository(id: String)
# ----------------------------------------------------------------------
# LOGOS ENDPOINT
# ----------------------------------------------------------------------
GET            /api/logos                                                               @api.Logos.list(path: Option[String] ?= None, name: Option[String] ?= None)
POST           /api/logos                                                               @api.Logos.upload
GET            /api/logos/:id                                                           @api.Logos.getId(id: UUID)
PUT            /api/logos/:id                                                           @api.Logos.putId(id: UUID)
GET            /api/logos/:id/blob                                                      @api.Logos.downloadId(id: UUID, default: Option[String] ?= None)
DELETE         /api/logos/:id                                                           @api.Logos.deleteId(id: UUID)
GET            /api/logos/:path/:name                                                   @api.Logos.getPath(path: String, name: String)
PUT            /api/logos/:path/:name                                                   @api.Logos.putPath(path: String, name: String)
GET            /api/logos/:path/:name/blob                                              @api.Logos.downloadPath(path: String, name: String, default: Option[String] ?= None)
DELETE         /api/logos/:path/:name                                                   @api.Logos.deletePath(path: String, name: String)

# ----------------------------------------------------------------------
# FILES ENDPOINT
# ----------------------------------------------------------------------
POST           /api/files/:three_d_file_id/geometries/:geometry_id                      @api.Files.attachGeometry(three_d_file_id: UUID,geometry_id: UUID)
POST           /api/files/:three_d_file_id/3dTextures/:texture_id                       @api.Files.attachTexture(three_d_file_id: UUID,texture_id: UUID)
POST           /api/files/:file_id/thumbnails/:thumbnail_id                             @api.Files.attachThumbnail(file_id: UUID,thumbnail_id: UUID)
POST           /api/queries/:file_id/thumbnails/:thumbnail_id                           @api.Files.attachQueryThumbnail(file_id: UUID,thumbnail_id: UUID)
GET            /api/files                                                               @api.Files.list
POST           /api/files                                                               @api.Files.upload(showPreviews: String ?= "DatasetLevel", originalZipFile: String ?= "", flags: String ?= "")
POST           /api/files/withFlags/:flags                                              @api.Files.upload(showPreviews: String ?= "DatasetLevel", originalZipFile: String ?= "", flags: String)
POST           /api/files/searchusermetadata                                            @api.Files.searchFilesUserMetadata
POST           /api/files/searchmetadata                                                @api.Files.searchFilesGeneralMetadata
POST           /api/uploadToDataset/withFlags/:id/:flags                                @api.Files.uploadToDataset(id: UUID, showPreviews: String ?= "DatasetLevel", originalZipFile: String ?= "", flags: String, extract: Boolean ?= true, folder_id: Option[String] ?= None)
POST           /api/uploadToDataset/:id                                                 @api.Files.uploadToDataset(id: UUID, showPreviews: String ?= "DatasetLevel", originalZipFile: String ?= "", flags: String ?= "", extract: Boolean ?= true, folder_id: Option[String] ?= None)
PUT            /api/files/:id/updateDescription                                         @api.Files.updateDescription(id: UUID)
POST           /api/files/uploadIntermediate/:idAndFlags                                @api.Files.uploadIntermediate(idAndFlags)
POST           /api/files/sendJob/:fileId/:fileType                                     @api.Files.sendJob(fileId: UUID,fileType)
GET            /api/files/getRDFURLsForFile/:id                                         @api.Files.getRDFURLsForFile(id: UUID)
GET            /api/files/rdfUserMetadata/:id                                           @api.Files.getRDFUserMetadata(id: UUID, mappingNum: String ?= "1")
GET            /api/files/:id/blob                                                      @api.Files.download(id: UUID, tracking: Boolean ?= true)

# deprecrated use DELETE
POST           /api/files/:id/remove                                                    @api.Files.removeFile(id: UUID)
POST           /api/files/bulkRemove                                                    @api.Files.bulkDeleteFiles()
GET            /api/files/:id/metadata                                                  @api.Files.get(id: UUID)
GET            /api/files/:id/sections                                                  @api.Files.sections(id: UUID)
POST           /api/files/:id/metadata                                                  @api.Files.addMetadata(id: UUID)
GET            /api/files/:id/metadataDefinitions                                       @api.Files.getMetadataDefinitions(id: UUID, space: Option[String] ?= None)
POST           /api/files/:id/updateMetadata                                            @api.Files.updateMetadata(id: UUID, extractor_id: String)
POST           /api/files/:id/versus_metadata                                           @api.Files.addVersusMetadata(id:UUID)
GET            /api/files/:id/versus_metadata                                           @api.Files.getVersusMetadataJSON(id:UUID)
GET            /api/files/:id/usermetadatajson                                          @api.Files.getUserMetadataJSON(id: UUID)
POST           /api/files/:id/usermetadata                                              @api.Files.addUserMetadata(id: UUID)
GET            /api/files/:id/technicalmetadatajson                                     @api.Files.getTechnicalMetadataJSON(id: UUID)
GET            /api/files/:id/xmlmetadatajson                                           @api.Files.getXMLMetadataJSON(id: UUID)
POST           /api/files/:id/follow                                                    @api.Files.follow(id: UUID)
POST           /api/files/:id/unfollow                                                  @api.Files.unfollow(id: UUID)
POST           /api/files/:id/comment                                                   @api.Files.comment(id: UUID)
DELETE         /api/files/:id                                                           @api.Files.removeFile(id: UUID)
GET            /api/files/:id/tags                                                      @api.Files.getTags(id: UUID)
POST           /api/files/:id/tags                                                      @api.Files.addTags(id: UUID)
# deprecrated use DELETE
POST           /api/files/:id/tags/remove                                               @api.Files.removeTags(id: UUID)
POST           /api/files/:id/tags/remove_all                                           @api.Files.removeAllTags(id: UUID)
DELETE         /api/files/:id/tags                                                      @api.Files.removeTags(id: UUID)
POST           /api/files/:id/license                                                   @api.Files.updateLicense(id: UUID)
GET            /api/files/:id/extracted_metadata                                        @api.Files.extract(id:UUID)
PUT            /api/files/:id/filename                                                  @api.Files.updateFileName(id: UUID)
POST           /api/files/:id/reindex                                                   @api.Files.reindex(id:UUID)
GET            /api/files/:id/users                                                     @api.Files.users(id: UUID)
GET            /api/files/:id/paths                                                     @api.Files.paths(id: UUID)
POST           /api/files/:id/archive                                                   @api.Files.archive(id: UUID)
POST           /api/files/:id/sendArchiveRequest                                        @api.Files.sendArchiveRequest(id: UUID)
POST           /api/files/:id/unarchive                                                 @api.Files.unarchive(id: UUID)
POST           /api/files/:id/sendUnarchiveRequest                                      @api.Files.sendUnarchiveRequest(id: UUID)

# ----------------------------------------------------------------------
# EXTRACTORS ENDPOINTS
# ----------------------------------------------------------------------
GET            /api/extractors                                                          @api.Extractions.listExtractors(categories: List[String] ?= List.empty, space: Option[UUID] ?= None)
GET            /api/extractors/:name                                                    @api.Extractions.getExtractorInfo(name: String, extractor_key: Option[String] ?= None)
POST           /api/extractors                                                          @api.Extractions.addExtractorInfo(extractor_key: Option[String] ?= None, user: Option[String] ?= None)
POST           /api/extractors/labels                                                   @api.Extractions.createExtractorsLabel()
PUT            /api/extractors/labels/:id                                               @api.Extractions.updateExtractorsLabel(id: UUID)
DELETE         /api/extractors/labels/:id                                               @api.Extractions.deleteExtractorsLabel(id: UUID)


POST           /api/files/:file_id/extractions                                          @api.Extractions.submitFileToExtractor(file_id: UUID)
POST           /api/datasets/:ds_id/extractions                                         @api.Extractions.submitDatasetToExtractor(ds_id: UUID)

GET            /api/extractions/requests                                                @api.Extractions.getDTSRequests()
GET            /api/extractions/servers_ips                                             @api.Extractions.getExtractorServersIP()
GET            /api/extractions/extractors_names                                        @api.Extractions.getExtractorNames(categories: List[String] ?= List.empty)
GET            /api/extractions/supported_input_types                                   @api.Extractions.getExtractorInputTypes()
#API for temporary fix for BD-289
GET            /api/extractions/extractors_details                                      @api.Extractions.getExtractorDetails()
POST           /api/extractions/upload_url                                              @api.Extractions.uploadByURL(extract: Boolean ?= true)
POST           /api/extractions/multiple_uploadby_url                                   @api.Extractions.multipleUploadByURL()
POST           /api/extractions/upload_file                                             @api.Extractions.uploadExtract(showPreviews: String ?= "DatasetLevel", extract: Boolean ?= true)
GET            /api/extractions/:id/status                                              @api.Extractions.checkExtractorsStatus(id:UUID)
GET            /api/extractions/:id/metadata                                            @api.Extractions.fetch(id:UUID)
GET            /api/extractions/:id/statuses                                            @api.Extractions.checkExtractionsStatuses(id:UUID)

DELETE         /api/extractions/:extractorName/delete                                   @api.Extractions.deleteExtractor(extractorName : String, extractor_key: Option[String] ?= None)

DELETE         /api/files/:file_id/extractions/:msg_id                                  @api.Extractions.cancelFileExtractionSubmission(file_id:UUID, msg_id: UUID)
DELETE         /api/datasets/:ds_id/extractions/:msg_id                                 @api.Extractions.cancelDatasetExtractionSubmission(ds_id:UUID, msg_id: UUID)

# End of change segment

# ----------------------------------------------------------------------
# PREVIEWS ENDPOINT
# ----------------------------------------------------------------------
POST           /api/files/:id/previews/:p_id                                            @api.Files.attachPreview(id: UUID, p_id: UUID)
GET            /api/files/:id/listpreviews                                              @api.Files.filePreviewsList(id: UUID)
GET            /api/files/:id/getPreviews                                               @api.Files.getPreviews(id: UUID)
GET            /api/files/:id/isBeingProcessed                                          @api.Files.isBeingProcessed(id: UUID)
#GET		   /api/files/:three_d_file_id/:filename			                        @api.Files.getGeometry(three_d_file_id: UUID, filename)
GET            /api/files/:three_d_file_id/:filename                                    @api.Files.getTexture(three_d_file_id: UUID, filename)
GET            /api/queries/:id                                                         @api.Files.downloadquery(id: UUID)
# TODO please use /api/files/:id/blob to get the actual data see MMDB-1685
GET            /api/files/:id                                                           @api.Files.download(id: UUID, tracking: Boolean ?= true)

# ----------------------------------------------------------------------
# DANGEROUS ENDPOINTS
# ----------------------------------------------------------------------
POST           /api/dumpFilesMd                                                         @api.Files.dumpFilesMetadata
POST           /api/dumpDatasetsMd                                                      @api.Datasets.dumpDatasetsMetadata
POST           /api/dumpDatasetGroupings                                                @api.Datasets.dumpDatasetGroupings

#----------------------------------------------------------------------
# 3D FILES
#----------------------------------------------------------------------
#GET		/api/files/:three_d_file_id/:filename			    @api.Files.getGeometry(three_d_file_id: UUID, filename)
GET            /api/files/:three_d_file_id/:filename                                    @api.Files.getTexture(three_d_file_id: UUID, filename)


# ----------------------------------------------------------------------
# SPACES ENDPOINT
# ----------------------------------------------------------------------
GET            /api/spaces                                                              @api.Spaces.list(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12)
GET            /api/spaces/canEdit                                                      @api.Spaces.listCanEdit(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12)
GET            /api/spaces/:id                                                          @api.Spaces.get(id: UUID)
GET            /api/spaces/:id/users                                                    @api.Spaces.getUsers(id: UUID)
POST           /api/spaces                                                              @api.Spaces.createSpace()
DELETE         /api/spaces/:id                                                          @api.Spaces.removeSpace(id: UUID)
POST           /api/spaces/:spaceId/removeCollection/:collectionId                      @api.Spaces.removeCollection(spaceId: UUID, collectionId: UUID, removeDatasets : Boolean)
POST           /api/spaces/:spaceId/removeDataset/:datasetId                            @api.Spaces.removeDataset(spaceId: UUID, datasetId: UUID)
POST           /api/spaces/:id/update                                                   @api.Spaces.updateSpace(id: UUID)
POST           /api/spaces/:id/updateUsers                                              @api.Spaces.updateUsers(id: UUID)
POST           /api/spaces/:id/acceptRequest                                            @api.Spaces.acceptRequest(id:UUID, user:String, role:String)
POST           /api/spaces/:id/rejectRequest                                            @api.Spaces.rejectRequest(id:UUID, user:String)
POST           /api/spaces/:id/removeUser                                               @api.Spaces.removeUser(id: UUID, removeUser: String)
POST           /api/spaces/:spaceId/addDatasetToSpace/:datasetId                        @api.Spaces.addDatasetToSpace(spaceId: UUID, datasetId: UUID)
POST           /api/spaces/:spaceId/addCollectionToSpace/:collectionId                  @api.Spaces.addCollectionToSpace(spaceId: UUID, collectionId: UUID)
POST           /api/spaces/:id/follow                                                   @api.Spaces.follow(id: UUID)
POST           /api/spaces/:id/unfollow                                                 @api.Spaces.unfollow(id: UUID)
POST           /api/spaces/:id/metadata                                                 @api.Metadata.addDefinitionToSpace(id: UUID)
PUT            /api/spaces/:id/verify                                                   @api.Spaces.verifySpace(id:UUID)
GET            /api/spaces/:id/datasets                                                 @api.Spaces.listDatasets(id: UUID, limit: Integer ?= 0)
GET            /api/spaces/:id/collections                                              @api.Spaces.listCollections(id: UUID, limit: Integer ?= 0)

# ----------------------------------------------------------------------
# COLLECTIONS ENDPOINT
# ----------------------------------------------------------------------
GET            /api/collections                                                         @api.Collections.list(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
GET            /api/collections/canEdit                                                 @api.Collections.listCanEdit(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
GET            /api/collections/datasetPossibleParents/:ds_id                           @api.Collections.addDatasetToCollectionOptions(when: Option[String] ?= None, ds_id: UUID, title: Option[String]?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
GET            /api/collections/possibleParents                                         @api.Collections.listPossibleParents(when: Option[String] ?= None, currentCollectionId: String, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
POST           /api/collections                                                         @api.Collections.createCollection()
GET            /api/collections/rootCollections                                         @api.Collections.getRootCollections
GET            /api/collections/topLevelCollections                                     @api.Collections.getTopLevelCollections
GET            /api/collections/allCollections                                          @api.Collections.getAllCollections(limit : Int ?= 0, showAll: Boolean ?=false)
GET            /api/collections/:id/download                                            @api.Collections.download(id: UUID, compression: Int ?= -1, bagit: Boolean ?= false)
GET            /api/collections/listTrash                                               @api.Collections.listCollectionsInTrash(limit : Int ?= 12)
DELETE         /api/collections/emptyTrash                                              @api.Collections.emptyTrash()
DELETE         /api/collections/clearOldCollectionsTrash                                @api.Collections.clearOldCollectionsTrash(days : Int ?= 30)
PUT            /api/collections/restore/:collectionId                                   @api.Collections.restoreCollection(collectionId : UUID)
# deprecrated
GET            /api/collections/list                                                    @api.Collections.list(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
POST           /api/collections/:id/follow                                              @api.Collections.follow(id: UUID)
POST           /api/collections/:id/unfollow                                            @api.Collections.unfollow(id: UUID)
GET            /api/collections/:coll_id/datasets                                       @api.Datasets.listInCollection(coll_id: UUID)
POST           /api/collections/:coll_id/datasets/:ds_id                                @api.Collections.attachDataset(coll_id: UUID, ds_id: UUID)
# deprecrated use DELETE
POST           /api/collections/:coll_id/datasetsRemove/:ds_id/:ignoreNotFound          @api.Collections.removeDataset(coll_id: UUID, ds_id: UUID,ignoreNotFound)
DELETE         /api/collections/:coll_id/datasets/:ds_id                                @api.Collections.removeDataset(coll_id: UUID, ds_id: UUID, ignoreNotFound ?= "True")
# deprecrated use DELETE
POST           /api/collections/:coll_id/remove                                         @api.Collections.removeCollection(coll_id: UUID)
POST           /api/collections/:coll_id/reindex                                        @api.Collections.reindex(coll_id: UUID, recursive: Boolean ?= true)
# deprecrated use datasets
GET            /api/collections/:coll_id/getDatasets                                    @api.Datasets.listInCollection(coll_id: UUID)
DELETE         /api/collections/:coll_id                                                @api.Collections.removeCollection(coll_id: UUID)
POST           /api/collections/:c_id/previews/:p_id                                    @api.Collections.attachPreview(c_id: UUID, p_id: UUID)
GET            /api/collections/:coll_id                                                @api.Collections.getCollection(coll_id: UUID)
PUT            /api/collections/:coll_id/title                                          @api.Collections.updateCollectionName(coll_id: UUID)
PUT            /api/collections/:coll_id/description                                    @api.Collections.updateCollectionDescription(coll_id: UUID)

POST           /api/collections/:coll_id/removeSubCollection/:sub_coll_id               @api.Collections.removeSubCollection(coll_id: UUID,sub_coll_id:UUID, ignoreNotFound?="True")
POST           /api/collections/:coll_id/rootFlag/:spaceId                              @api.Collections.setRootSpace(coll_id: UUID, spaceId: UUID)
POST           /api/collections/:coll_id/unsetRootFlag/:spaceId                         @api.Collections.unsetRootSpace(coll_id: UUID, spaceId: UUID)
POST           /api/collections/newCollectionWithParent                                 @api.Collections.createCollectionWithParent
GET            /api/collections/:coll_id/getChildCollectionIds                          @api.Collections.getChildCollectionIds(coll_id: UUID)
GET            /api/collections/:coll_id/getChildCollections                            @api.Collections.getChildCollections(coll_id: UUID)
GET            /api/collections/:coll_id/getParentCollectionIds                         @api.Collections.getParentCollectionIds(coll_id: UUID)
GET            /api/collections/:coll_id/getParentCollections                           @api.Collections.getParentCollections(coll_id: UUID)
POST           /api/collections/:coll_id/addSubCollection/:sub_coll_id                  @api.Collections.attachSubCollection(coll_id: UUID, sub_coll_id: UUID)
GET            /api/collections/:coll_id/removeFromSpaceAllowed/:space_id               @api.Collections.removeFromSpaceAllowed(coll_id: UUID, space_id: UUID)

# ----------------------------------------------------------------------
# DATASETS ENDPOINT
# ----------------------------------------------------------------------
GET            /api/datasets                                                            @api.Datasets.list(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
GET            /api/datasets/canEdit                                                    @api.Datasets.listCanEdit(when: Option[String] ?= None, title: Option[String] ?= None, date: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
GET            /api/datasets/moveFileToDataset                                          @api.Datasets.listMoveFileToDataset(file_id: UUID, title: Option[String] ?= None, limit: Int ?= 12, exact: Boolean ?= false)
POST           /api/datasets                                                            @api.Datasets.createDataset
POST           /api/datasets/createempty                                                @api.Datasets.createEmptyDataset
POST           /api/datasets/createfrombag                                              @api.Datasets.createFromBag
POST           /api/datasets/attachmultiple                                             @api.Datasets.attachMultipleFiles
POST           /api/datasets/searchusermetadata                                         @api.Datasets.searchDatasetsUserMetadata
POST           /api/datasets/searchmetadata                                             @api.Datasets.searchDatasetsGeneralMetadata
GET            /api/datasets/listOutsideCollection/:coll_id                             @api.Datasets.listOutsideCollection(coll_id: UUID)
GET            /api/datasets/listTrash                                                  @api.Datasets.listDatasetsInTrash(limit : Int ?= 12)
DELETE         /api/datasets/emptyTrash                                                 @api.Datasets.emptyTrash()
DELETE         /api/datasets/clearOldDatasetsTrash                                      @api.Datasets.clearOldDatasetsTrash(days : Int ?= 30)
PUT            /api/datasets/restore/:id                                                @api.Datasets.restoreDataset(id : UUID)
POST           /api/datasets/:ds_id/filesRemove/:file_id/:ignoreNotFound                @api.Datasets.detachFile(ds_id: UUID,file_id: UUID, ignoreNotFound)
POST           /api/datasets/:datasetId/moveFile/:toFolder/:fileId                      @api.Folders.moveFileBetweenFolders( datasetId: UUID, toFolder: UUID, fileId: UUID)
POST           /api/datasets/:datasetId/moveBetweenDatasets/:toDataset/:fileId          @api.Datasets.moveFileBetweenDatasets(datasetId: UUID, toDataset: UUID, fileId: UUID)
POST           /api/datasets/:datasetId/moveToDataset/:fromFolder/:fileId               @api.Folders.moveFileToDataset(datasetId: UUID, fromFolder: UUID, fileId: UUID)
DELETE         /api/datasets/:parentDatasetId/deleteFolder/:folderId                    @api.Folders.deleteFolder(parentDatasetId: UUID, folderId: UUID)
PUT            /api/datasets/:parentDatasetId/updateName/:folderId                      @api.Folders.updateFolderName(parentDatasetId: UUID, folderId: UUID)
POST           /api/datasets/:datasetId/copyDatasetToSpace/:spaceId                     @api.Datasets.copyDatasetToSpace(datasetId: UUID, spaceId: UUID)
GET            /api/datasets/:datasetId/folders                                         @api.Folders.getAllFoldersByDatasetId(datasetId: UUID)
DELETE         /api/datasets/:ds_id/:file_id                                            @api.Datasets.detachFile(ds_id: UUID,file_id: UUID, ignoreNotFound ?= "True")
GET            /api/datasets/getRDFURLsForDataset/:id                                   @api.Datasets.getRDFURLsForDataset(id: UUID)
GET            /api/datasets/rdfUserMetadata/:id                                        @api.Datasets.getRDFUserMetadata(id: UUID, mappingNum: String ?= "1")
GET            /api/datasets/:id/metadata                                               @api.Datasets.getMetadataDefinitions(id: UUID, space: Option[String] ?= None)
POST           /api/datasets/:id/metadata                                               @api.Datasets.addMetadata(id: UUID)
POST           /api/datasets/:id/usermetadata                                           @api.Datasets.addUserMetadata(id: UUID)
GET            /api/datasets/:id/technicalmetadatajson                                  @api.Datasets.getTechnicalMetadataJSON(id: UUID)
GET            /api/datasets/:id/xmlmetadatajson                                        @api.Datasets.getXMLMetadataJSON(id: UUID)
GET            /api/datasets/:id/usermetadatajson                                       @api.Datasets.getUserMetadataJSON(id: UUID)
POST           /api/datasets/:id/filesetUploadEvent                                     @api.Extractions.addNewFilesetEvent(id: String, fileids: List[String])
GET            /api/datasets/:id/listFiles                                              @api.Datasets.datasetFilesList(id: UUID, count: Boolean ?= false)
GET            /api/datasets/:id/listAllFiles                                           @api.Datasets.datasetAllFilesList(id:UUID, max: Int ?= -1)
GET            /api/datasets/:id/files                                                  @api.Datasets.datasetAllFilesList(id: UUID, max: Int ?= -1)
POST           /api/datasets/:id/files                                                  @api.Datasets.uploadToDatasetFile(id: UUID)
POST           /api/datasets/:id/urls                                                   @api.Datasets.uploadToDatasetJSON(id: UUID)
GET            /api/datasets/:id/download                                               @api.Datasets.download(id: UUID, bagit: Boolean ?= false, compression: Int ?= -1, tracking: Boolean ?= true)
GET            /api/datasets/:id/downloadPartial                                        @api.Datasets.downloadPartial(id: UUID, fileList: String, bagit: Boolean ?= false)
GET            /api/datasets/:id/downloadFolder                                         @api.Datasets.downloadFolder(id: UUID, folderId: UUID, bagit: Boolean ?= false)
POST           /api/datasets/:id/comment                                                @api.Datasets.comment(id: UUID)
POST           /api/datasets/:id/reindex                                                @api.Datasets.reindex(id:UUID, recursive: Boolean ?= true)
POST           /api/datasets/:id/follow                                                 @api.Datasets.follow(id: UUID)
POST           /api/datasets/:id/unfollow                                               @api.Datasets.unfollow(id: UUID)
POST           /api/datasets/:id/removeTag                                              @api.Datasets.removeTag(id: UUID)
GET            /api/datasets/:id/tags                                                   @api.Datasets.getTags(id: UUID)
POST           /api/datasets/:id/tags                                                   @api.Datasets.addTags(id: UUID)
# deprecrated use DELETE
POST           /api/datasets/:id/tags/remove                                            @api.Datasets.removeTags(id: UUID)
POST           /api/datasets/:id/tags/remove_all                                        @api.Datasets.removeAllTags(id: UUID)
DELETE         /api/datasets/:id/tags                                                   @api.Datasets.removeTags(id: UUID)
PUT            /api/datasets/:id/title                                                  @api.Datasets.updateName(id:UUID)
PUT            /api/datasets/:id/description                                            @api.Datasets.updateDescription(id: UUID)
POST           /api/datasets/:id/creator	                                            @api.Datasets.addCreator(id: UUID)
DELETE		   /api/datasets/:id/creator/remove											@api.Datasets.removeCreator(id: UUID, creator: String)
PUT			   /api/datasets/:id/creator/reorder										@api.Datasets.moveCreator(id: UUID, creator: String, newPos: Int)
POST           /api/datasets/:id/editing                                                @api.Datasets.updateInformation(id: UUID)
POST           /api/datasets/:id/license                                                @api.Datasets.updateLicense(id: UUID)
GET            /api/datasets/:id/isBeingProcessed                                       @api.Datasets.isBeingProcessed(id: UUID)
GET            /api/datasets/:id/getPreviews                                            @api.Datasets.getPreviews(id: UUID)
POST           /api/datasets/:ds_id/files/:file_id                                      @api.Datasets.attachExistingFile(ds_id: UUID,file_id: UUID)
GET            /api/datasets/:id                                                        @api.Datasets.get(id: UUID)
DELETE         /api/datasets/:id                                                        @api.Datasets.deleteDataset(id: UUID)
POST           /api/datasets/:id/detachdelete                                           @api.Datasets.detachAndDeleteDataset(id: UUID)
POST           /api/datasets/:parentDatasetId/newFolder                                 @api.Folders.createFolder(parentDatasetId: UUID)
PUT            /api/datasets/:id/access                                                 @api.Datasets.updateAccess(id:UUID, aceess:String ?="PRIVATE")
POST           /api/datasets/:id/addFileEvent                                           @api.Datasets.addFileEvent(id:UUID, inFolder:Boolean, fileCount: Int )
GET            /api/datasets/:id/users                                                  @api.Datasets.users(id:UUID)
POST           /api/datasets/:id/queueArchival                                          @api.Datasets.queueArchival(id: UUID)
POST           /api/datasets/:id/queueUnarchival                                        @api.Datasets.queueUnarchival(id: UUID)

# ----------------------------------------------------------------------
# PREVIEWS ENDPOINT
# ----------------------------------------------------------------------
GET            /api/previews/:preview_id/textures/dataset/:datasetid/json               @api.Previews.downloadPreview(preview_id: UUID, datasetid: UUID)
GET            /api/previews/:preview_id/textures/dataset/:dataset_id//:filename        @api.Files.downloadByDatasetAndFilename(dataset_id: UUID, filename, preview_id: UUID)
GET            /api/previews/:dzi_id_dir/:level/:filename                               @api.Previews.getTile(dzi_id_dir, level, filename)
POST           /api/previews/:dzi_id/tiles/:tile_id/:level                              @api.Previews.attachTile(dzi_id: UUID, tile_id: UUID, level)
POST           /api/previews/:id/metadata                                               @api.Previews.uploadMetadata(id: UUID)
GET            /api/previews/:id/metadata                                               @api.Previews.getMetadata(id: UUID)
POST           /api/previews/:id/annotationAdd                                          @api.Previews.attachAnnotation(id: UUID)
POST           /api/previews/:id/annotationEdit                                         @api.Previews.editAnnotation(id: UUID)
GET            /api/previews/:id/annotationsList                                        @api.Previews.listAnnotations(id: UUID)
POST           /api/previews/:id/title                                                  @api.Previews.setTitle(id: UUID)
GET            /api/previews                                                            @api.Previews.list
GET            /api/previews/:id                                                        @api.Previews.download(id: UUID)
DELETE         /api/previews/:id                                                        @api.Previews.removePreview(id: UUID)
POST           /api/previews                                                            @api.Previews.upload(iipKey: String ?= "")
POST           /api/indexes                                                             @api.Indexes.index
POST           /api/indexes/features                                                    @api.Indexes.features

# ----------------------------------------------------------------------
# SECTIONS ENDPOINT
# ----------------------------------------------------------------------
POST           /api/sections                                                            @api.Sections.add
POST           /api/sections/:id/comments                                               @api.Sections.comment(id: UUID)
POST           /api/sections/:id/description                                            @api.Sections.description(id: UUID)
POST           /api/sections/:id/thumbnails/:thumbnail_id                               @api.Sections.attachThumbnail(id: UUID,thumbnail_id: UUID)
GET            /api/sections/:id/tags                                                   @api.Sections.getTags(id: UUID)
POST           /api/sections/:id/tags                                                   @api.Sections.addTags(id: UUID)
# Deprecated for delete
POST           /api/sections/:id/tags/remove                                            @api.Sections.removeTags(id: UUID)
POST           /api/sections/:id/tags/remove_all                                        @api.Sections.removeAllTags(id: UUID)
DELETE         /api/sections/:id/tags                                                   @api.Sections.removeTags(id: UUID)
GET            /api/sections/:id                                                        @api.Sections.get(id: UUID)
DELETE         /api/sections/:id                                                        @api.Sections.delete(id: UUID)

# ----------------------------------------------------------------------
# SEARCH ENDPOINT
# ----------------------------------------------------------------------
GET            /api/search/json                                                         @api.Search.searchJson(query: String ?= "", grouping: String ?= "AND", from: Option[Int], size: Option[Int])
GET            /api/search/multimediasearch                                             @api.Search.searchMultimediaIndex(section_id: UUID)
GET            /api/search                                                              @api.Search.search(query: String ?= "", resource_type: Option[String], datasetid: Option[String], collectionid: Option[String], spaceid: Option[String], folderid: Option[String], field: Option[String], tag: Option[String], from: Option[Int], size: Option[Int], page: Option[Int], sort: Option[String], order: Option[String])

# ----------------------------------------------------------------------
# GEOSTREAMS ENDPOINT
# ----------------------------------------------------------------------
POST           /api/geostreams/datapoints                                               api.Geostreams.addDatapoint(invalidateCache: Boolean ?= true)
POST           /api/geostreams/datapoints/bulk                                          api.Geostreams.addDatapoints(invalidateCache: Boolean ?= true)
DELETE         /api/geostreams/datapoints/:id                                           api.Geostreams.deleteDatapoint(id: String)
GET            /api/geostreams/datapoints                                               api.Geostreams.searchDatapoints(operator = "", since: Option[String] ?= None, until: Option[String] ?= None, geocode: Option[String] ?= None,  stream_id: Option[String] ?= None, sensor_id: Option[String] ?= None, sources: List[String] ?= List.empty, attributes: List[String] ?= List.empty, format: String ?= "json", semi: Option[String], onlyCount: Boolean ?=false, window_start: Option[String] = None, window_end: Option[String] = None, binning: String ?= "semi", geojson: Option[String] ?= None)
GET            /api/geostreams/datapoints/averages                                      api.Geostreams.searchDatapoints(operator = "averages", since: Option[String] ?= None, until: Option[String] ?= None, geocode: Option[String] ?= None,  stream_id: Option[String] ?= None, sensor_id: Option[String] ?= None, sources: List[String] ?= List.empty, attributes: List[String] ?= List.empty, format: String ?= "json", semi: Option[String], onlyCount: Boolean ?=false, window_start: Option[String] = None, window_end: Option[String] = None, binning: String ?= "semi", geojson: Option[String] ?= None)
GET            /api/geostreams/datapoints/trends                                        api.Geostreams.searchDatapoints(operator = "trends", since: Option[String] ?= None, until: Option[String] ?= None, geocode: Option[String] ?= None,  stream_id: Option[String] ?= None, sensor_id: Option[String] ?= None, sources: List[String] ?= List.empty, attributes: List[String] ?= List.empty, format: String ?= "json", semi: Option[String], onlyCount: Boolean ?=false, window_start: Option[String] ?= None, window_end: Option[String] ?= None, binning: String ?= "semi", geojson: Option[String] ?= None)
GET            /api/geostreams/datapoints/bin/:time/:depth                              api.Geostreams.binDatapoints(time, depth: Double, raw: Boolean ?= false, since: Option[String] ?= None, until: Option[String] ?= None, geocode: Option[String] ?= None,  stream_id: Option[String] ?= None, sensor_id: Option[String] ?= None, sources: List[String] ?= List.empty, attributes: List[String] ?= List.empty)
GET            /api/geostreams/datapoints/:id                                           api.Geostreams.getDatapoint(id: String)
GET            /api/geostreams/cache                                                    api.Geostreams.cacheListAction
GET            /api/geostreams/cache/invalidate                                         api.Geostreams.cacheInvalidateAction(sensor_id: Option[String] ?= None, stream_id: Option[String] ?= None)
GET            /api/geostreams/cache/:id                                                api.Geostreams.cacheFetchAction(id)
POST           /api/geostreams/sensors                                                  api.Geostreams.createSensor
GET            /api/geostreams/sensors/update                                           api.Geostreams.updateStatisticsStreamSensor()
GET            /api/geostreams/sensors/:id                                              api.Geostreams.getSensor(id: String)
PUT            /api/geostreams/sensors/:id                                              api.Geostreams.updateSensorMetadata(id: String)
GET            /api/geostreams/sensors/:id/stats                                        api.Geostreams.getSensorStatistics(id: String)
GET            /api/geostreams/sensors/:id/streams                                      api.Geostreams.getSensorStreams(id: String)
GET            /api/geostreams/sensors/:id/update                                       api.Geostreams.updateStatisticsSensor(id: String)
GET            /api/geostreams/sensors                                                  api.Geostreams.searchSensors(geocode: Option[String] ?= None, sensor_name: Option[String] ?= None, geojson: Option[String] ?= None)
DELETE         /api/geostreams/sensors/:id                                              api.Geostreams.deleteSensor(id: String)
POST           /api/geostreams/streams                                                  api.Geostreams.createStream
GET            /api/geostreams/streams/update                                           api.Geostreams.updateStatisticsStreamSensor()
GET            /api/geostreams/streams/:id                                              api.Geostreams.getStream(id: String)
PUT            /api/geostreams/streams/:id                                              api.Geostreams.patchStreamMetadata(id: String)
GET            /api/geostreams/streams/:id/update                                       api.Geostreams.updateStatisticsStream(id: String)
GET            /api/geostreams/streams                                                  api.Geostreams.searchStreams(geocode: Option[String] ?= None, stream_name: Option[String] ?= None, geojson: Option[String] ?= None)
DELETE         /api/geostreams/streams/:id                                              api.Geostreams.deleteStream(id: String)
DELETE         /api/geostreams/dropall                                                  api.Geostreams.deleteAll
GET            /api/geostreams/counts                                                   api.Geostreams.counts
GET            /api/geostreams/config                                                   api.Geostreams.getConfig

# ----------------------------------------------------------------------
# THUMBNAILS ENDPOINT
# ----------------------------------------------------------------------
POST           /api/fileThumbnail                                                       @api.Thumbnails.uploadThumbnail
GET            /api/thumbnails                                                          @api.Thumbnails.list
GET            /api/thumbnails/:id/blob                                                 @api.Thumbnails.get(id: UUID)
DELETE         /api/thumbnails/:id                                                      @api.Thumbnails.removeThumbnail(id: UUID)

# ----------------------------------------------------------------------
# SENSORS ENDPOINT
# ----------------------------------------------------------------------
GET            /api/sensors                                                             api.Sensors.list
POST           /api/sensors                                                             api.Sensors.add
GET            /api/sensors/:id                                                         api.Sensors.get(id)
GET            /api/sensors/search                                                      api.Sensors.search
DELETE         /api/sensors/:id                                                         api.Sensors.delete(id)

# ----------------------------------------------------------------------
# COMMENTS ENDPOINT
# ----------------------------------------------------------------------
POST           /api/comment/mention                                                     @api.Comments.mentionInComment(userID: UUID, resourceID: UUID, resourceName: String, resourceType: String, commenterId: UUID)
POST           /api/comment/:id                                                         @api.Comments.comment(id: UUID)
DELETE         /api/comment/:id/removeComment                                           @api.Comments.removeComment(id: UUID)
POST           /api/comment/:id/editComment                                             @api.Comments.editComment(id: UUID)

# ----------------------------------------------------------------------
# SELECTIONS API
# ----------------------------------------------------------------------
GET            /selected                                                                @controllers.Selected.get
GET            /datasets/submit/:ds_id                                                  @controllers.Extractors.submitSelectedExtractions(ds_id: UUID)
GET            /api/selected                                                            @api.Selected.get
POST           /api/selected                                                            @api.Selected.add
POST           /api/selected/remove                                                     @api.Selected.remove
DELETE         /api/selected/files                                                      @api.Selected.deleteAll
GET            /api/selected/files                                                      @api.Selected.downloadAll
POST           /api/selected/clear                                                      @api.Selected.clearAll
POST           /api/selected/tag                                                        @api.Selected.tagAll(tags: List[String])
POST           /api/selected/submit/:ds_id/:file_ids                                    @api.Extractions.submitFilesToExtractor(ds_id: UUID, file_ids: String)

# ----------------------------------------------------------------------
# RELATIONS API
# ----------------------------------------------------------------------
GET            /api/relations                                                           @api.Relations.list()
GET            /api/relations/search                                                    @api.Relations.findTargets(sourceId: String, sourceType: String, targetType: String)
GET            /api/relations/:id                                                       @api.Relations.get(id: UUID)
POST           /api/relations                                                           @api.Relations.add()
DELETE         /api/relations/:id                                                       @api.Relations.delete(id: UUID)

# ----------------------------------------------------------------------
# REPORTING API
# ----------------------------------------------------------------------
GET            /api/reports/metrics                                                     @api.Reporting.allMetrics()
GET            /api/reports/metrics/files                                               @api.Reporting.fileMetrics(since: Option[String] ?= None, until: Option[String] ?= None)
GET            /api/reports/metrics/datasets                                            @api.Reporting.datasetMetrics(since: Option[String] ?= None, until: Option[String] ?= None)
GET            /api/reports/metrics/collections                                         @api.Reporting.collectionMetrics()
GET            /api/reports/metrics/spaces                                              @api.Reporting.spaceMetrics()
GET            /api/reports/metrics/users                                               @api.Reporting.userMetrics()
GET            /api/reports/storage/spaces                                              @api.Reporting.spaceStorage(space: Option[String] ?= None, since: Option[String] ?= None, until: Option[String] ?= None)
GET            /api/reports/metrics/extractors                                          @api.Reporting.extractorUsage(since: Option[String] ?= None, until: Option[String] ?= None)


# ----------------------------------------------------------------------
# MISC./OTHER ENDPOINTS
# ----------------------------------------------------------------------
POST           /api/tiles                                                               @api.ZoomIt.uploadTile
POST           /api/geometries                                                          @api.Geometry.uploadGeometry
POST           /api/3dTextures                                                          @api.ThreeDTexture.uploadTexture
POST           /api/sparqlquery                                                         @api.Search.querySPARQL
POST           /api/projects/addproject                                                 @api.Projects.addproject(project: String)
POST           /api/institutions/addinstitution                                         @api.Institutions.addinstitution(institution: String)

# ----------------------------------------------------------------------
# USERS API
# ----------------------------------------------------------------------
GET            /api/users                                                               @api.Users.list
GET            /api/users/email/:email                                                  @api.Users.findByEmail(email: String)
GET            /api/me                                                                  @api.Users.getUser()
POST           /api/users/:id/updateName                                                @api.Users.updateName(id: UUID, firstName: String, lastName: String)
GET            /api/users/keys                                                          @api.Users.keysList()
GET            /api/users/keys/:name                                                    @api.Users.keysGet(name: String)
POST           /api/users/keys                                                          @api.Users.keysAdd(name: String)
DELETE         /api/users/keys/:key                                                     @api.Users.keysDelete(key: String)
POST           /api/users/addUserDatasetView                                            @api.Users.addUserDatasetView(email: String, dataset: UUID)
POST           /api/users/createNewListInUser                                           @api.Users.createNewListInUser(email: String, field: String, fieldList: List[String])
POST           /api/users/follow                                                        @api.Users.follow(followeeUUID: UUID)
POST           /api/users/unfollow                                                      @api.Users.unfollow(followeeUUID: UUID)
GET            /api/curations/:curationId/ore                                           @api.CurationObjects.getCurationObjectOre(curationId: UUID)
GET            /api/users/:id                                                           @api.Users.findById(id: UUID)

# ----------------------------------------------------------------------
# USERS Controller
# ----------------------------------------------------------------------
GET            /users/followers                                                         @controllers.Users.getFollowers(index: Int ?= 0, limit: Int ?=12)
GET            /users/following                                                         @controllers.Users.getFollowing(index: Int ?= 0, limit: Int ?=12)

# ----------------------------------------------------------------------
# Clowder STATUS API
# ----------------------------------------------------------------------
GET            /api/version                                                             @api.Status.version
GET            /api/status                                                              @api.Status.status

# ----------------------------------------------------------------------
# RSS
# ----------------------------------------------------------------------
GET            /rss                                                                     @controllers.RSS.siteRSS(limit: Option[Int])
GET            /rss/:etype                                                              @controllers.RSS.siteRSSOfType(limit: Option[Int], etype: String)

# ----------------------------------------------------------------------
# CURATIONS ENDPOINT (PUBLICATION REQUESTS)
# ----------------------------------------------------------------------

GET            /dataset/:id/curations/new                                               @controllers.CurationObjects.newCO(id:UUID, space:String ?= "")
GET            /space/curations                                                         @controllers.CurationObjects.list(when: String ?= "", date: String ?= "", limit: Int ?= 4, space: Option[String] ?= None)
POST           /dataset/:id/curations/spaces/:spaceId/submit                            @controllers.CurationObjects.submit(id:UUID, spaceId:UUID)
GET            /spaces/:id/stagingArea                                                  @controllers.Spaces.stagingArea(id: UUID, index: Int ?=0, limit: Int ?= 12)
GET            /spaces/curations/:id                                                    @controllers.CurationObjects.getCurationObject(id: UUID, limit: Int ?=5)
DELETE         /spaces/curations/retract/:id                                            @api.CurationObjects.retractCurationObject(id: UUID)
GET            /spaces/curations/:id/edit                                               @controllers.CurationObjects.editCuration(id: UUID)
POST           /spaces/curations/:id/spaces/:spaceId/update                             @controllers.CurationObjects.updateCuration(id: UUID, spaceId:UUID)
DELETE         /spaces/curations/:id                                                    @controllers.CurationObjects.deleteCuration(id: UUID)
GET            /spaces/curations/:id/compareToRepository                                @controllers.CurationObjects.compareToRepository(id: UUID, repository:String)
POST           /spaces/curations/:id/submitRepositorySelection                          @controllers.CurationObjects.submitRepositorySelection(id: UUID)
GET            /spaces/curations/:id/sendToRepository                                   @controllers.CurationObjects.sendToRepository(id: UUID)
GET            /spaces/curations/:id/matchmaker                                         @controllers.CurationObjects.findMatchingRepositories(id: UUID)
POST           /spaces/curations/:id/matchmaker                                         @api.CurationObjects.findMatchmakingRepositories(id: UUID)
GET            /spaces/curations/:id/curationFile                                       @api.CurationObjects.getCurationFiles(id: UUID)
POST           /spaces/curations/:id/status                                             @api.CurationObjects.savePublishedObject(id: UUID)
GET            /spaces/curations/:id/getStatusFromRepository                            @controllers.CurationObjects.getStatusFromRepository(id: UUID)
DELETE         /spaces/curations/:id/files/:curationFileId                              @api.CurationObjects.deleteCurationFile(id:UUID, parentId: UUID, curationFileId: UUID)
DELETE         /spaces/curations/:id/folders/:curationFolderId                          @api.CurationObjects.deleteCurationFolder(id:UUID, parentId: UUID, curationFolderId: UUID)
GET            /spaces/curations/:id/updatedFilesAndFolders                             @controllers.CurationObjects.getUpdatedFilesAndFolders(id: UUID, curationFolderId: String, limit: Int, pageIndex:Int)
GET            /spaces/curations/:id/getMetadataDefinitionsByFile                       @api.CurationObjects.getMetadataDefinitionsByFile(id: UUID)
GET            /spaces/curations/:id/metadataDefinitions                                @api.CurationObjects.getMetadataDefinitions(id: UUID)
GET            /publishedData		                                                    @controllers.CurationObjects.getPublishedData(space: String = "")
GET            /publishedData/:space	                                                @controllers.CurationObjects.getPublishedData(space: String)

POST           /sendEmail                                                               @api.Events.sendExceptionEmail()
GET            /getEvents                                                               @controllers.Events.getEvents(index: Int)

# ----------------------------------------------------------------------
# VOCABULARIES API
# ----------------------------------------------------------------------

GET         /api/vocabularies/list                                                      @api.Vocabularies.list()
POST        /api/vocabularies/createVocabularyFromJson                                  @api.Vocabularies.createVocabularyFromJson(isPublic : Boolean ?= false)
POST        /api/vocabularies/createVocabulary                                          @api.Vocabularies.createVocabularyFromForm()
GET         /api/vocabularies/getByAuthor                                               @api.Vocabularies.getByAuthor()
GET         /api/vocabularies/getPublic                                                 @api.Vocabularies.getPublicVocabularies()


GET         /api/vocabularies/:vocab_id                                                 @api.Vocabularies.get(vocab_id : UUID)
PUT         /api/editVocabulary/:vocab_id                                               @api.Vocabularies.editVocabulary(vocab_id : UUID)
GET         /api/vocabularies/:name                                                     @api.Vocabularies.getByName(name : String)
GET         /api/vocabularies/:name/getByNameAuthor                                     @api.Vocabularies.getByNameAndAuthor(name: String)

POST        /api/vocabularies/:vocab_id/addToSpace/:space_id                            @api.Vocabularies.addToSpace(vocab_id: UUID, space_id : UUID)
POST        /api/vocabuliaries/:vocab_id/removeFromSpace/:space_id                      @api.Vocabularies.removeFromSpace(vocab_id: UUID, space_id : UUID)

# ----------------------------------------------------------------------
# VOCABULARYTERMS API
# ----------------------------------------------------------------------

GET         /api/vocabterms/list                                                        @api.VocabularyTerms.list()
GET         /api/vocabterms/:id                                                         @api.VocabularyTerms.get(id : UUID)


# ----------------------------------------------------------------------
# STANDARDVOCABULARY API
# ----------------------------------------------------------------------

GET          /api/standardvocab                                                            @api.Metadata.getVocabularies()
POST         /api/standardvocab                                                            @api.Metadata.createVocabulary()
GET          /api/standardvocab/:id                                                        @api.Metadata.getVocabulary(id: UUID)
GET          /api/standardvocab/:id/terms                                                  @api.Metadata.getVocabularyTerms(id: UUID)
PUT          /api/standardvocab/:id                                                        @api.Metadata.updateVocabulary(id:UUID)
DELETE       /api/standardvocab/:id                                                        @api.Metadata.deleteVocabulary(id: UUID)

# ----------------------------------------------------------------------
# PROXY API
# ----------------------------------------------------------------------

POST        /api/proxy/:endpoint_key                                                        @api.Proxy.post(endpoint_key: String, pathSuffix: String = null)
POST        /api/proxy/:endpoint_key/                                                       @api.Proxy.post(endpoint_key: String, pathSuffix: String = "")
POST        /api/proxy/:endpoint_key/*pathSuffix                                            @api.Proxy.post(endpoint_key: String, pathSuffix: String)
PUT         /api/proxy/:endpoint_key                                                        @api.Proxy.put(endpoint_key: String, pathSuffix: String = null)
PUT         /api/proxy/:endpoint_key/                                                       @api.Proxy.put(endpoint_key: String, pathSuffix: String = "")
PUT         /api/proxy/:endpoint_key/*pathSuffix                                            @api.Proxy.put(endpoint_key: String, pathSuffix: String)
DELETE      /api/proxy/:endpoint_key                                                        @api.Proxy.delete(endpoint_key: String, pathSuffix: String = null)
DELETE      /api/proxy/:endpoint_key/                                                       @api.Proxy.delete(endpoint_key: String, pathSuffix: String = "")
DELETE      /api/proxy/:endpoint_key/*pathSuffix                                            @api.Proxy.delete(endpoint_key: String, pathSuffix: String)

# ----------------------------------------------------------------------
# EXTRACTOR VIEWS
# ----------------------------------------------------------------------


GET         /extractors                                                                     @controllers.Extractors.selectExtractors()
POST        /extractors                                                                     @controllers.Extractors.updateExtractors()


# ----------------------------------------------------------------------
# TREE API
# ----------------------------------------------------------------------

GET         /api/tree/getChildrenOfNode                                                     @api.Tree.getChildrenOfNode(nodeType : String ?= "root", nodeId : Option[String] ?= None, mine : Boolean ?= false)