openbel-api 0.4.0-java

data/app/openbel/api/resources/match_result.rb

@@ -0,0 +1,79 @@
+require 'bel'
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module MatchResults
+
+      class MatchResultSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :match_result
+          properties do |p|
+            p.match_text     item.snippet
+            p.rdf_uri        item.uri
+            p.rdf_scheme_uri item.scheme_uri
+            p.identifier     item.identifier
+            p.name           item.pref_label
+
+            # Do not have alt_labels property from FTS index.
+            # p.synonyms       item.alt_labels
+          end
+        end
+      end
+
+      class MatchResultResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :'match_result'
+          properties do |p|
+            collection :match_results, item, MatchResultSerializer
+          end
+
+          # link :self,        link_self(item.first[:short_form])
+        end
+
+        # private
+        #
+        # def link_self(id)
+        #   {
+        #     :type => :function,
+        #     :href => "#{base_url}/api/functions/#{id}"
+        #   }
+        # end
+      end
+
+      class MatchResultCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :'match_result_collection'
+          properties do |p|
+            collection :match_results, item, MatchResultSerializer
+          end
+
+          # link :self,       link_self
+          # link :start,      link_start(item[0][:short_form])
+        end
+
+        # private
+        #
+        # def link_self
+        #   {
+        #     :type => :'function_collection',
+        #     :href => "#{base_url}/api/functions"
+        #   }
+        # end
+        #
+        # def link_start(first_function)
+        #   {
+        #     :type => :function,
+        #     :href => "#{base_url}/api/functions/#{first_function}"
+        #   }
+        # end
+      end
+    end
+  end
+end

data/app/openbel/api/resources/namespace.rb

@@ -0,0 +1,174 @@
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module Namespaces
+
+      VOCABULARY_RDF = 'http://www.openbel.org/vocabulary/'
+
+      class NamespaceValueSearchResult < BEL::Resource::NamespaceValue
+
+        def match_text=(match_text)
+          @match_text = match_text
+        end
+
+        def match_text
+          @match_text
+        end
+      end
+
+      class NamespaceSerializer < BaseSerializer
+#        adapter Oat::Adapters::HAL
+        schema do
+          type     :namespace
+          property :rdf_uri, item.uri.to_s
+          property :name,    item.prefLabel
+          property :prefix,  item.prefix
+          property :domain,  item.domain
+        end
+      end
+
+      class NamespaceResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :namespace
+          property :namespace,  item
+          link     :self,       link_self(item)
+          link     :collection, link_collection
+        end
+
+        private
+
+        def link_self(item)
+          {
+            :type => :namespace,
+            :href => "#{base_url}/api/namespaces/#{item[:prefix]}"
+          }
+        end
+
+        def link_collection
+          {
+            :type => :namespace_collection,
+            :href => "#{base_url}/api/namespaces"
+          }
+        end
+      end
+
+      class NamespaceCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :namespace_collection
+          property :namespace_collection, item
+          link     :self,                 link_self
+          link     :start,                link_start
+        end
+
+        private
+
+        def link_self
+          {
+            :type => :namespace_collection,
+            :href => "#{base_url}/api/namespaces"
+          }
+        end
+
+        def link_start
+          {
+            :type => :start,
+            :href => "#{base_url}/api/namespaces/values"
+          }
+        end
+      end
+
+      class NamespaceValueSerializer < BaseSerializer
+        #adapter Oat::Adapters::HAL
+        schema do
+          type     :namespace_value
+          property :rdf_uri,       item.uri.to_s
+          property :type,          [item.type].flatten.map(&:to_s)
+          property :identifier,    item.identifier
+          property :name,          item.prefLabel
+          property :title,         item.title
+          property :species,       item.fromSpecies
+          entity   :namespace,     item.namespace, NamespaceSerializer
+
+          # Support inclusion of the matched text when annotation values are filtered by
+          # a full-text search.
+          if item.match_text
+            property :match_text,    item.match_text
+          end
+        end
+      end
+
+      class NamespaceValueResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          parts = URI(item.delete(:rdf_uri)).path.split('/')[3..-1]
+          namespace_id = parts[0]
+          namespace_value_id = parts.join('/')
+
+          type     :namespace_value
+          property :namespace_value, item
+          link     :self,            link_self(namespace_value_id)
+          link     :collection,      link_namespace(namespace_id)
+          link     :equivalents,     link_equivalents(namespace_value_id)
+          link     :orthologs,       link_orthologs(namespace_value_id)
+        end
+
+        private
+
+        def link_self(id)
+          {
+            :type => :namespace_value,
+            :href => "#{base_url}/api/namespaces/#{id}"
+          }
+        end
+
+        def link_namespace(id)
+          {
+            :type => :namespace,
+            :href => "#{base_url}/api/namespaces/#{id}"
+          }
+        end
+
+        def link_equivalents(id)
+          {
+            :type => :namespace_value_collection,
+            :href => "#{base_url}/api/namespaces/#{id}/equivalents"
+          }
+        end
+
+        def link_orthologs(id)
+          {
+            :type => :namespace_value_collection,
+            :href => "#{base_url}/api/namespaces/#{id}/orthologs"
+          }
+        end
+      end
+
+      class NamespaceValueCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :namespace_value_collection
+          property :namespace_value_collection, item
+        end
+      end
+
+      class ValueEquivalenceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type :value_equivalence
+          property :value,         item.value
+          property :type,          item.type ? item.type.sub(VOCABULARY_RDF, '') : nil
+          property :identifier,    item.identifier
+          property :title,         item.title
+          property :species,       item.fromSpecies
+          property :namespace_uri, item.inScheme
+
+          property :value_equivalence_collection, item.equivalences, NamespaceValueSerializer
+        end
+      end
+    end
+  end
+end
+# vim: ts=2 sw=2

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

@@ -0,0 +1,168 @@
+require 'bel'
+
+module OpenBEL
+  module Routes
+
+    class Annotations < Base
+      include BEL::Language
+
+      SORTED_FUNCTIONS = FUNCTIONS.values.uniq.sort_by { |fx|
+        fx[:short_form]
+      }
+
+      def initialize(app)
+        super
+
+        # RdfRepository using Jena.
+        @rr = BEL::RdfRepository.plugins[:jena].create_repository(
+          :tdb_directory => OpenBEL::Settings[:resource_rdf][:jena][:tdb_directory]
+        )
+
+        # Annotations using RdfRepository
+        @annotations = BEL::Resource::Annotations.new(@rr)
+
+        # Resource Search using SQLite.
+        @search = BEL::Resource::Search.plugins[:sqlite].create_search(
+          :database_file => OpenBEL::Settings[:resource_search][:sqlite][:database_file]
+        )
+      end
+
+      options '/api/annotations' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/annotations/values' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/annotations/:annotation' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/annotations/:annotation/values' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/annotations/:annotation/values/:value' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      get '/api/annotations' do
+        annotations = @annotations.each.to_a
+        halt 404 if not annotations or annotations.empty?
+
+        render_collection(
+          annotations.sort { |x,y|
+            x.prefLabel.to_s <=> y.prefLabel.to_s
+          },
+          :annotation
+        )
+      end
+
+      get '/api/annotations/values' do
+        start    = (params[:start]  ||  0).to_i
+        size     = (params[:size]   || -1).to_i
+        size     = -1 if size <= 0
+        faceted  = as_bool(params[:faceted])
+        halt 501 if faceted
+
+        filter_hash = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
+        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}
+          filter_hash[filter['category']][filter['name']] = filter['value']
+        end
+
+        halt 404 unless filter_hash['fts']['search'].is_a?(String)
+        match = filter_hash['fts']['search']
+        halt 404 unless match.length > 1
+
+        match_results  = @search.search(wildcard_match(match), :annotation_concept, nil, nil,
+          :start => start,
+          :size => size
+        ).map { |result|
+          value = OpenBEL::Resource::Annotations::AnnotationValueSearchResult.new(@rr, result.uri)
+          value.match_text = result.snippet
+          value
+        }.to_a
+
+        halt 404 if not match_results or match_results.empty?
+        render_collection(
+          match_results,
+          :annotation_value,
+          :adapter => Oat::Adapters::BasicJson
+        )
+      end
+
+      get '/api/annotations/:annotation' do |annotation|
+        annotation = @annotations.find(annotation).first
+        halt 404 unless annotation
+
+        status 200
+        render_resource(annotation, :annotation)
+      end
+
+      get '/api/annotations/:annotation/values' do |annotation|
+        annotation = @annotations.find(annotation).first
+        halt 404 unless annotation
+
+        start    = (params[:start]  ||  0).to_i
+        size     = (params[:size]   || -1).to_i
+        size     = -1 if size <= 0
+        faceted  = as_bool(params[:faceted])
+        halt 501 if faceted
+
+        filter_hash = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
+        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}
+          filter_hash[filter['category']][filter['name']] = filter['value']
+        end
+
+        halt 404 unless filter_hash['fts']['search'].is_a?(String)
+        match = filter_hash['fts']['search']
+        halt 404 unless match.length > 1
+
+        match_results = @search.search(wildcard_match(match), :annotation_concept, annotation.uri.to_s, nil,
+          :start => start,
+          :size => size
+        ).map { |result|
+          value = OpenBEL::Resource::Annotations::AnnotationValueSearchResult.new(@rr, result.uri)
+          value.match_text = result.snippet
+          value
+        }.to_a
+
+        halt 404 if not match_results or match_results.empty?
+        render_collection(
+          match_results,
+          :annotation_value,
+          :adapter => Oat::Adapters::BasicJson
+        )
+      end
+
+      get '/api/annotations/:annotation/values/:value' do |annotation, value|
+        annotation = @annotations.find(annotation).first
+        halt 404 unless annotation
+
+        value = annotation.find(value).first
+        halt 404 unless value
+
+        status 200
+        render_resource(
+          value,
+          :annotation_value,
+          :adapter => Oat::Adapters::BasicJson
+        )
+      end
+    end
+  end
+end
+# vim: ts=2 sw=2:
+# encoding: utf-8

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

@@ -0,0 +1,108 @@
+require 'uri'
+require 'rest-client'
+
+def current_host(env)
+  scheme = env['rack.url_scheme'] || 'http'
+  host = env['HTTP_HOST']
+  "#{scheme}://#{host}"
+end
+
+def current_path(env)
+  scheme = env['rack.url_scheme'] || 'http'
+  host = env['HTTP_HOST']
+  path = env['PATH_INFO']
+  "#{scheme}://#{host}#{path}"
+end
+
+module OpenBEL
+  module Routes
+
+    class Authenticate < Base
+
+      get '/api/authenticate' do
+        state = params[:state]
+        code = params[:code]
+        if code.nil?
+          default_connection = OpenBEL::Settings[:auth][:default_connection]
+          default_auth_url = current_path(env) + "/#{default_connection}"
+          if not state.nil?
+            default_auth_url += "?state=#{state}"
+          end
+          redirect to(default_auth_url)
+        end
+
+        domain = OpenBEL::Settings[:auth][:domain]
+        id = OpenBEL::Settings[:auth][:id]
+        secret = OpenBEL::Settings[:auth][:secret]
+
+        callback_url = current_path(env)
+        payload =  {
+            client_id: id,
+            client_secret: secret,
+            redirect_uri: callback_url,
+            code: code,
+            grant_type: :authorization_code
+        }
+
+        token_url = "https://#{domain}/oauth/token"
+        body = payload.to_json
+
+        begin
+          token_response = RestClient.post token_url, body,
+                                           :content_type => :json,
+                                           :accept => :json
+        rescue => e
+          hdrs = {'Content-Type' => 'application/json'}
+          msg = {error: e.response }
+          return [401, hdrs, [msg.to_json]]
+        end
+
+        token_response = JSON.parse(token_response)
+        access_token = token_response['access_token']
+        jwt = token_response['id_token']
+
+        user_url = "https://#{domain}/userinfo?access_token=#{access_token}"
+        begin
+          user_response = RestClient.get user_url, :accept => :json
+        rescue => e
+          hdrs = {'Content-Type' => 'application/json'}
+          msg = {error: e.response }
+          return [401, hdrs, [msg.to_json]]
+        end
+
+        email = JSON.parse(user_response)['email']
+        hdrs = {'Content-Type' => 'application/json'}
+        msg = {success: email}
+        cookies[:jwt] = jwt
+        if not state.nil?
+          redirect to(state + "?jwt=#{jwt}")
+        else
+          [200, hdrs, [msg.to_json]]
+        end
+      end
+
+      get '/api/authenticate/:connection' do
+        state = params[:state]
+        redirect_setting = OpenBEL::Settings[:auth][:redirect]
+        connection = params[:connection]
+        redirect_uri = current_host(env) + '/api/authenticate'
+        auth_url = "#{redirect_setting}"
+        auth_url += "&redirect_uri=#{redirect_uri}"
+        auth_url += "&connection=#{connection}"
+        if not state.nil?
+          auth_url += "&state=#{state}"
+        end
+        redirect to(auth_url)
+      end
+
+      get '/api/authentication-enabled' do
+        enabled = OpenBEL::Settings[:auth][:enabled]
+        hdrs = {'Content-Type' => 'application/json'}
+        msg = {enabled: enabled}
+        return [200, hdrs, [msg.to_json]]
+      end
+    end
+  end
+end
+# vim: ts=2 sw=2:
+# encoding: utf-8