openbel-api 0.4.0-java

data/app/openbel/api/routes/base.rb

@@ -0,0 +1,326 @@
+require 'bel'
+require 'json_schema'
+require 'multi_json'
+require_relative '../resources/annotation'
+require_relative '../resources/completion'
+require_relative '../resources/evidence'
+require_relative '../resources/function'
+require_relative '../resources/match_result'
+require_relative '../resources/namespace'
+require_relative '../schemas'
+
+module OpenBEL
+  module Routes
+
+    class Base < Sinatra::Application
+      include OpenBEL::Resource::Annotations
+      include OpenBEL::Resource::Evidence
+      include OpenBEL::Resource::Expressions
+      include OpenBEL::Resource::Functions
+      include OpenBEL::Resource::MatchResults
+      include OpenBEL::Resource::Namespaces
+      include OpenBEL::Schemas
+
+      DEFAULT_CONTENT_TYPE   = 'application/hal+json'
+      SPOKEN_CONTENT_TYPES   = %w[application/hal+json application/json]
+      SPOKEN_CONTENT_TYPES.concat(
+        BEL::Translator.plugins.values.flat_map { |p| p.media_types.map(&:to_s) }
+      )
+
+      SCHEMA_BASE_URL        = 'http://next.belframework.org/schemas/'
+      RESOURCE_SERIALIZERS   = {
+        :annotation                 => AnnotationResourceSerializer,
+        :annotation_collection      => AnnotationCollectionSerializer,
+        :annotation_value           => AnnotationValueResourceSerializer,
+        :completion                 => CompletionResourceSerializer,
+        :completion_collection      => CompletionCollectionSerializer,
+        :function                   => FunctionResourceSerializer,
+        :function_collection        => FunctionCollectionSerializer,
+        :match_result               => MatchResultResourceSerializer,
+        :match_result_collection    => MatchResultCollectionSerializer,
+        :namespace                  => NamespaceResourceSerializer,
+        :namespace_collection       => NamespaceCollectionSerializer,
+        :namespace_value            => NamespaceValueResourceSerializer,
+        :namespace_value_collection => NamespaceValueCollectionSerializer,
+        :evidence                   => EvidenceSerializer,
+        :evidence_resource          => EvidenceResourceSerializer,
+        :evidence_collection        => EvidenceCollectionSerializer
+      }
+
+      disable :protection
+
+      before do
+        unless request.preferred_type(SPOKEN_CONTENT_TYPES)
+          halt 406
+        end
+      end
+
+      helpers do
+
+        def as_bool(value)
+          value == nil ? false : value.to_s =~ (/^(true|t|yes|y|1|on)$/i)
+        end
+
+        def wildcard_match(match)
+          match.to_s.split(/\W/).map { |v| "*#{v}*"}.join(' ')
+        end
+
+        def request_headers
+          env.inject({}) { |hdrs, (k,v)|
+            hdrs[$1.downcase] = v if k =~ /^http_(.*)/i
+            hdrs
+          }
+        end
+
+        def base_url
+          env['HTTP_X_REAL_BASE_URL'] ||
+            "#{env['rack.url_scheme']}://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}"
+        end
+
+        def url
+          env['HTTP_X_REAL_URL'] ||
+            "#{env['rack.url_scheme']}://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}/#{env['PATH_INFO']}"
+        end
+
+        def schema_url(name)
+          SCHEMA_BASE_URL + "#{name}.schema.json"
+        end
+
+        def validate_media_type!(content_type, options = {})
+          ctype = request.content_type
+          valid = ctype.start_with? content_type
+          if options[:profile]
+            valid &= (%r{profile=#{options[:profile]}} =~ ctype)
+          end
+
+          unless valid
+            halt(
+              415,
+              {
+                'Content-Type' => 'application/json'
+              },
+              render_json({
+                :status => 415,
+                :msg => "Invalid media type #{ctype} (profile: #{options[:profile]})"
+              })
+            )
+          end
+        end
+
+        def read_evidence
+          halt 415 unless ::BEL.translator(request.media_type)
+          ::BEL.evidence(request.body, request.media_type, :symbolize_keys => true)
+        end
+
+        def read_json
+          request.body.rewind
+          begin
+            MultiJson.load(request.body.read, :symbolize_keys => true)
+          rescue MultiJson::ParseError => ex
+            halt(
+              400,
+              {
+                'Content-Type' => 'application/json'
+              },
+              render_json({
+                :status => 400,
+                :msg => 'Invalid JSON body.',
+                :detail => ex.cause.to_s
+              })
+            )
+          end
+        end
+
+        def read_filter(filter_json)
+          begin
+            MultiJson.load filter_json
+          rescue MultiJson::ParseError => ex
+            halt(
+              400,
+              {
+                'Content-Type' => 'application/json'
+              },
+              render_json({
+                :status => 400,
+                :msg => "Invalid JSON filter: #{filter_json}.",
+                :detail => ex.cause.to_s
+              })
+            )
+          end
+        end
+
+        def render_json(obj, media_type = 'application/hal+json', profile = nil)
+          ctype =
+            if profile
+              "#{media_type}; profile=#{profile}"
+            else
+              media_type
+            end
+          response.headers['Content-Type'] = ctype.to_s
+          MultiJson.dump obj
+        end
+
+        def validate_schema(data, type)
+          self.validate(data, type)
+        end
+
+        def render_resource(obj, type, options = {})
+          media_type = 'application/hal+json'
+          resource_context = {
+            :base_url => base_url,
+            :url      => url
+          }.merge(options)
+
+          type_class = type.to_s.split('_').map(&:capitalize).join
+          type_serializer     = self.class.const_get("#{type_class}Serializer")
+          resource_serializer = self.class.const_get("#{type_class}ResourceSerializer")
+
+          adapter = Oat::Adapters::HAL
+          if options[:adapter]
+            adapter = options[:adapter]
+          end
+
+          resource = resource_serializer.new(
+            type_serializer.new(obj, resource_context, adapter).to_hash,
+            resource_context,
+            adapter
+          ).to_hash
+
+          render_json(resource.to_hash, media_type)
+        end
+
+        def render_collection(collection, type, options = {})
+          media_type = 'application/hal+json'
+          resource_context = {
+            :base_url => base_url,
+            :url      => url
+          }.merge(options)
+
+          type_class = type.to_s.split('_').map(&:capitalize).join
+          serializer          = self.class.const_get("#{type_class}Serializer")
+          type_serializer     = self.class.const_get("#{type_class}ResourceSerializer")
+          resource_serializer = self.class.const_get("#{type_class}CollectionSerializer")
+
+          adapter = Oat::Adapters::HAL
+          if options[:adapter]
+            adapter = options[:adapter]
+          end
+
+          resource = resource_serializer.new(
+            collection.map { |obj|
+              single = serializer.new(obj, resource_context, adapter).to_hash
+              type_serializer.new(single, resource_context, adapter).to_hash
+            },
+            resource_context,
+            adapter
+          ).to_hash
+
+          render_json(resource.to_hash, media_type)
+        end
+
+        def render(obj, type, options = {})
+          media_type = 'application/hal+json'
+          resource_context = {
+            :base_url => base_url,
+            :url      => url
+          }.merge(options)
+
+          serializer_class = RESOURCE_SERIALIZERS[type]
+          unless serializer_class
+            raise NotImplementedError.new("Cannot serialize the #{type} resource.")
+          end
+
+          adapter = Oat::Adapters::HAL
+
+          # XXX hack to fix OpenBEL/openbel-server#33
+          if options[:as_array]
+            render_json(
+              {
+                type => [serializer_class.new(obj, resource_context, adapter).to_hash]
+              },
+              media_type
+            )
+          else
+            render_json(
+              serializer_class.new(obj, resource_context, adapter).to_hash,
+              media_type
+            )
+          end
+        end
+
+        def stream_resource_collection(type, collection, facets, options = {})
+          serializer_class = RESOURCE_SERIALIZERS[type]
+          unless serializer_class
+            raise NotImplementedError.new("Cannot serialize the #{type} resource collection.")
+          end
+
+          media_type = resolve_supported_content_type(request)
+          resource_context = {
+            :base_url => base_url,
+            :url      => url
+          }.merge(options)
+
+          adapter = Oat::Adapters::HAL
+
+          response.headers['Content-Type'] = media_type
+          collection_enum = collection.to_enum
+
+          stream do |response|
+            response << %Q({"#{type}": [)
+            item = collection_enum.next
+            response << render_json(
+              serializer_class.new(item, resource_context, adapter).to_hash,
+              media_type
+            )
+            while true
+              begin
+                item = collection_enum.next
+                response << (',' + render_json(
+                  serializer_class.new(item, resource_context, adapter).to_hash,
+                  media_type
+                ))
+              rescue StopIteration
+                break
+              end
+            end
+            response << ']'
+
+            if facets
+              response << ',"facets": ['
+
+              facet_enum = facets.to_enum
+              facet_item = facet_enum.next
+              filter = MultiJson.load(facet_item['_id'])
+              response << MultiJson.dump({
+                :category => filter['category'].to_sym,
+                :name     => filter['name'].to_sym,
+                :value    => filter['value'],
+                :filter   => facet_item['_id'],
+                :count    => facet_item['count']
+              })
+              while true
+                begin
+                  facet_item = facet_enum.next
+                  filter = MultiJson.load(facet_item['_id'])
+                  response << (',' + MultiJson.dump({
+                    :category => filter['category'].to_sym,
+                    :name     => filter['name'].to_sym,
+                    :value    => filter['value'],
+                    :filter   => facet_item['_id'],
+                    :count    => facet_item['count']
+                  }))
+                rescue StopIteration
+                  break
+                end
+              end
+              response << ']'
+            end
+
+            response << '}'
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/openbel/api/routes/datasets.rb

@@ -0,0 +1,519 @@
+require 'bel'
+require 'rdf'
+require 'cgi'
+require 'multi_json'
+require 'openbel/api/evidence/mongo'
+require 'openbel/api/evidence/facet_filter'
+require_relative '../resources/evidence_transform'
+require_relative '../helpers/pager'
+
+module OpenBEL
+  module Routes
+
+    class Datasets < Base
+      include OpenBEL::Evidence::FacetFilter
+      include OpenBEL::Resource::Evidence
+      include OpenBEL::Helpers
+
+      DEFAULT_TYPE = 'application/hal+json'
+
+      ACCEPTED_TYPES = {
+        :bel  => 'application/bel',
+        :xml  => 'application/xml',
+        :xbel => 'application/xml',
+        :json => 'application/json',
+      }
+
+      def initialize(app)
+        super
+
+        # Evidence API using Mongo.
+        @api = OpenBEL::Evidence::Evidence.new(
+          :host     => OpenBEL::Settings[:evidence_store][:mongo][:host],
+          :port     => OpenBEL::Settings[:evidence_store][:mongo][:port],
+          :database => OpenBEL::Settings[:evidence_store][:mongo][:database]
+        )
+
+        # RdfRepository using Jena.
+        @rr = BEL::RdfRepository.plugins[:jena].create_repository(
+          :tdb_directory => OpenBEL::Settings[:resource_rdf][:jena][:tdb_directory]
+        )
+
+        # Load RDF monkeypatches.
+        BEL::Translator.plugins[:rdf].create_translator
+
+        # Annotations using RdfRepository
+        annotations = BEL::Resource::Annotations.new(@rr)
+        @annotation_transform = AnnotationTransform.new(annotations)
+      end
+
+      # Hang on to the Rack IO in order to do unbuffered reads.
+      # use Rack::Config do |env|
+      #   env['rack.input'], env['data.input'] = StringIO.new, env['rack.input']
+      # end
+
+      configure do
+        ACCEPTED_TYPES.each do |ext, mime_type|
+          mime_type(ext, mime_type)
+        end
+      end
+
+      helpers do
+
+        def check_dataset(io, type)
+          begin
+            evidence         = BEL.evidence(io, type).each.first
+
+            unless evidence
+              halt(
+                400,
+                { 'Content-Type' => 'application/json' },
+                render_json({ :status => 400, :msg => 'No BEL evidence was provided. Evidence is required to infer dataset information.' })
+              )
+            end
+
+            void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{self.generate_uuid}")
+
+            void_dataset = evidence.to_void_dataset(void_dataset_uri)
+            unless void_dataset
+              halt(
+                  400,
+                  { 'Content-Type' => 'application/json' },
+                  render_json({ :status => 400, :msg => 'The dataset document does not contain a document header.' })
+              )
+            end
+
+            identifier_statement = void_dataset.query(
+                RDF::Statement.new(void_dataset_uri, RDF::DC.identifier, nil)
+            ).to_a.first
+            unless identifier_statement
+              halt(
+                  400,
+                  { 'Content-Type' => 'application/json' },
+                  render_json(
+                    {
+                      :status => 400,
+                      :msg => 'The dataset document does not contain the Name or Version needed to build an identifier.'
+                    }
+                  )
+              )
+            end
+
+            datasets         = @rr.query_pattern(RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset))
+            existing_dataset = datasets.find { |dataset_statement|
+              @rr.has_statement?(
+                  RDF::Statement.new(dataset_statement.subject, RDF::DC.identifier, identifier_statement.object)
+              )
+            }
+
+            if existing_dataset
+              dataset_uri = existing_dataset.subject.to_s
+              headers 'Location' => dataset_uri
+              halt(
+                  409,
+                  { 'Content-Type' => 'application/json' },
+                  render_json(
+                      {
+                          :status => 409,
+                          :msg => %Q{The dataset document matches an existing dataset resource by identifier "#{identifier_statement.object}".},
+                          :location => dataset_uri
+                      }
+                  )
+              )
+            end
+
+            [void_dataset_uri, void_dataset]
+          ensure
+            io.rewind
+          end
+        end
+
+        def dataset_exists?(uri)
+          @rr.has_statement?(
+            RDF::Statement.new(uri, RDF.type, RDF::VOID.Dataset)
+          )
+        end
+
+        def retrieve_dataset(uri)
+          dataset = {}
+          identifier = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.identifier, nil)
+          ).first
+          dataset[:identifier] = identifier.object.to_s if identifier
+
+          title = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.title, nil)
+          ).first
+          dataset[:title] = title.object.to_s if title
+
+          description = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.description, nil)
+          ).first
+          dataset[:description] = description.object.to_s if description
+
+          waiver = @rr.query(
+            RDF::Statement.new(uri, RDF::URI('http://vocab.org/waiver/terms/waiver'), nil)
+          ).first
+          dataset[:waiver] = waiver.object.to_s if waiver
+
+          creator = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.creator, nil)
+          ).first
+          dataset[:creator] = creator.object.to_s if creator
+
+          license = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.license, nil)
+          ).first
+          dataset[:license] = license.object.to_s if license
+
+          publisher = @rr.query(
+            RDF::Statement.new(uri, RDF::DC.publisher, nil)
+          ).first
+          if publisher
+            publisher.object
+            contact_info = @rr.query(
+              RDF::Statement.new(publisher.object, RDF::FOAF.mbox, nil)
+            ).first
+            dataset[:contact_info] = contact_info.object.to_s if contact_info
+          end
+
+          dataset
+        end
+      end
+
+      options '/api/datasets' do
+        response.headers['Allow'] = 'OPTIONS,POST,GET'
+        status 200
+      end
+
+      options '/api/datasets/:id' do
+        response.headers['Allow'] = 'OPTIONS,GET,PUT,DELETE'
+        status 200
+      end
+
+      post '/api/datasets' do
+        if request.media_type == 'multipart/form-data' && params['file']
+          io, filename, type = params['file'].values_at(:tempfile, :filename, :type)
+          unless ACCEPTED_TYPES.values.include?(type)
+            type = mime_type(File.extname(filename))
+          end
+
+          halt(
+            415,
+            { 'Content-Type' => 'application/json' },
+            render_json({
+                          :status => 415,
+                          :msg => %Q{
+[Form data] Do not support content type for "#{type || filename}" when processing datasets from the "file" form parameter.
+The following content types are allowed: #{ACCEPTED_TYPES.values.join(', ')}. The "file" form parameter type can also be inferred by the following file extensions: #{ACCEPTED_TYPES.keys.join(', ')}} })
+          ) unless ACCEPTED_TYPES.values.include?(type)
+        elsif ACCEPTED_TYPES.values.include?(request.media_type)
+          type = request.media_type
+          io   = request.body
+
+          halt(
+            415,
+            { 'Content-Type' => 'application/json' },
+            render_json({
+                          :status => 415,
+                          :msg => %Q{[POST data] Do not support content type #{type} when processing datasets. The following content types
+are allowed in the "Content-Type" header: #{ACCEPTED_TYPES.values.join(', ')}} })
+          ) unless ACCEPTED_TYPES.values.include?(type)
+        else
+          halt(
+            400,
+            { 'Content-Type' => 'application/json' },
+            render_json({
+              :status => 400,
+              :msg => %Q{Please POST data using a supported "Content-Type" or a "file" parameter using
+the "multipart/form-data" content type. Allowed dataset content types are: #{ACCEPTED_TYPES.values.join(', ')}} })
+          )
+        end
+
+        # Check dataset in request for suitability and conflict with existing resources.
+        void_dataset_uri, void_dataset = check_dataset(io, type)
+
+        # Create dataset in RDF.
+        @rr.insert_statements(void_dataset)
+
+        dataset = retrieve_dataset(void_dataset_uri)
+
+        # Add slices of read evidence objects; save to Mongo and RDF.
+        BEL.evidence(io, type).each.lazy.each_slice(500) do |slice|
+          slice.map! do |ev|
+            # Standardize annotations from experiment_context.
+            @annotation_transform.transform_evidence!(ev, base_url)
+
+            # Add filterable metadata field for dataset identifier.
+            ev.metadata[:dataset] = dataset[:identifier]
+
+            facets           = map_evidence_facets(ev)
+            ev.bel_statement = ev.bel_statement.to_s
+            hash             = ev.to_h
+            hash[:facets]    = facets
+
+            # Create dataset field for efficient removal.
+            hash[:_dataset]  = dataset[:identifier]
+            hash
+          end
+
+          _ids = @api.create_evidence(slice)
+
+          dataset_parts = _ids.map { |object_id|
+            RDF::Statement.new(void_dataset_uri, RDF::DC.hasPart, object_id.to_s)
+          }
+          @rr.insert_statements(dataset_parts)
+        end
+
+        status 201
+        headers 'Location' => void_dataset_uri.to_s
+      end
+
+      get '/api/datasets/:id' do
+        id = params[:id]
+        void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{id}")
+        halt 404 unless dataset_exists?(void_dataset_uri)
+
+        status 200
+        render_json({
+          :dataset => retrieve_dataset(void_dataset_uri),
+          :_links => {
+            :self => {
+                :type => 'dataset',
+                :href => void_dataset_uri.to_s
+            },
+            :evidence_collection => {
+              :type => 'evidence_collection',
+              :href => "#{base_url}/api/datasets/#{id}/evidence"
+            }
+          }
+        })
+      end
+
+      get '/api/datasets/:id/evidence' do
+        id = params[:id]
+        void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{id}")
+        halt 404 unless dataset_exists?(void_dataset_uri)
+
+        dataset = retrieve_dataset(void_dataset_uri)
+
+        start                = (params[:start]  || 0).to_i
+        size                 = (params[:size]   || 0).to_i
+        faceted              = as_bool(params[:faceted])
+        max_values_per_facet = (params[:max_values_per_facet] || 0).to_i
+
+        # check filters
+        filters = []
+        filter_params = CGI::parse(env["QUERY_STRING"])['filter']
+        filter_params.each do |filter|
+          filter = read_filter(filter)
+          halt 400 unless ['category', 'name', 'value'].all? { |f| filter.include? f}
+
+          if filter['category'] == 'fts' && filter['name'] == 'search'
+            unless filter['value'].to_s.length > 1
+              halt(
+                400,
+                { 'Content-Type' => 'application/json' },
+                render_json({
+                  :status => 400,
+                  :msg => 'Full-text search filter values must be larger than one.'
+                })
+              )
+            end
+          end
+
+          # Remove dataset filters since we're filtering a specific one already.
+          next if filter.values_at('category', 'name') == ['metadata', 'dataset']
+
+          filters << filter
+        end
+
+        collection_total  = @api.count_evidence
+        filtered_total    = @api.count_evidence(filters)
+        page_results      = @api.find_dataset_evidence(dataset, filters, start, size, faceted)
+
+        accept_type = request.accept.find { |accept_entry|
+          ACCEPTED_TYPES.values.include?(accept_entry.to_s)
+        }
+        accept_type ||= DEFAULT_TYPE
+
+        if params[:format]
+          translator  = BEL::Translator.plugins[params[:format].to_sym]
+          halt 501 if !translator || translator.id == :rdf
+          accept_type = [translator.media_types].flatten.first
+        end
+
+        if accept_type == DEFAULT_TYPE
+          evidence          = page_results[:cursor].map { |item|
+            item.delete('facets')
+            item
+          }.to_a
+
+          facets            = page_results[:facets]
+
+          halt 404 if evidence.empty?
+
+          pager = Pager.new(start, size, filtered_total)
+
+          options = {
+            :start    => start,
+            :size     => size,
+            :filters  => filter_params,
+            :metadata => {
+              :collection_paging => {
+                :total                  => collection_total,
+                :total_filtered         => pager.total_size,
+                :total_pages            => pager.total_pages,
+                :current_page           => pager.current_page,
+                :current_page_size      => evidence.size,
+              }
+            }
+          }
+
+          if facets
+            # group by category/name
+            hashed_values = Hash.new { |hash, key| hash[key] = [] }
+            facets.each { |facet|
+              filter         = read_filter(facet['_id'])
+              category, name = filter.values_at('category', 'name')
+              next if !category || !name
+
+              key = [category.to_sym, name.to_sym]
+              facet_obj = {
+                :value    => filter['value'],
+                :filter   => facet['_id'],
+                :count    => facet['count']
+              }
+              hashed_values[key] << facet_obj
+            }
+
+            if max_values_per_facet == 0
+              facet_hashes = hashed_values.map { |(category, name), value_objects|
+                {
+                  :category => category,
+                  :name     => name,
+                  :values   => value_objects
+                }
+              }
+            else
+              facet_hashes = hashed_values.map { |(category, name), value_objects|
+                {
+                  :category => category,
+                  :name     => name,
+                  :values   => value_objects.take(max_values_per_facet)
+                }
+              }
+            end
+
+            options[:facets] = facet_hashes
+          end
+
+          # pager links
+          options[:previous_page] = pager.previous_page
+          options[:next_page]     = pager.next_page
+
+          render_collection(evidence, :evidence, options)
+        else
+          out_translator = BEL.translator(accept_type)
+          extension      = ACCEPTED_TYPES.key(accept_type.to_s)
+
+          response.headers['Content-Type'] = accept_type
+          status 200
+          attachment "#{dataset[:identifier].gsub(/[^\w]/, '_')}.#{extension}"
+          stream :keep_open do |response|
+            cursor             = page_results[:cursor]
+            json_evidence_enum = cursor.lazy.map { |evidence|
+              evidence.delete('facets')
+              evidence.delete('_id')
+              evidence.keys.each do |key|
+                evidence[key.to_sym] = evidence.delete(key)
+              end
+              BEL::Model::Evidence.create(evidence)
+            }
+
+            out_translator.write(json_evidence_enum) do |converted_evidence|
+              response << converted_evidence
+            end
+          end
+        end
+      end
+
+      get '/api/datasets' do
+        dataset_uris = @rr.query(
+          RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset)
+        ).map { |statement|
+          statement.subject
+        }.to_a
+        halt 404 if dataset_uris.empty?
+
+        dataset_collection = dataset_uris.map { |uri|
+          {
+            :dataset => retrieve_dataset(uri),
+            :_links => {
+                :self => {
+                    :type => 'dataset',
+                    :href => uri.to_s
+                },
+                :evidence_collection => {
+                    :type => 'evidence_collection',
+                    :href => "#{uri}/evidence"
+                }
+            }
+          }
+        }
+
+        status 200
+        render_json({ :dataset_collection => dataset_collection })
+      end
+
+      delete '/api/datasets/:id' do
+        id = params[:id]
+        void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{id}")
+        halt 404 unless dataset_exists?(void_dataset_uri)
+
+        dataset = retrieve_dataset(void_dataset_uri)
+        @api.delete_dataset(dataset[:identifier])
+        @rr.delete_statement(RDF::Statement.new(void_dataset_uri, nil, nil))
+
+        status 202
+      end
+
+      delete '/api/datasets' do
+        datasets = @rr.query(
+          RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset)
+        ).map { |stmt|
+          stmt.subject
+        }.to_a
+        halt 404 if datasets.empty?
+
+        datasets.each do |void_dataset_uri|
+          dataset = retrieve_dataset(void_dataset_uri)
+          @api.delete_dataset(dataset[:identifier])
+          @rr.delete_statement(RDF::Statement.new(void_dataset_uri, nil, nil))
+        end
+
+        status 202
+      end
+
+      private
+
+      unless self.methods.include?(:generate_uuid)
+
+        # Dynamically defines an efficient UUID method for the current ruby.
+        if RUBY_ENGINE =~ /^jruby/i
+          java_import 'java.util.UUID'
+          define_method(:generate_uuid) do
+            Java::JavaUtil::UUID.random_uuid.to_s
+          end
+        else
+          require 'uuid'
+          define_method(:generate_uuid) do
+            UUID.generate
+          end
+        end
+      end
+    end
+  end
+end
+# vim: ts=2 sw=2:
+# encoding: utf-8