assaydepot 0.0.1 → 0.1.1

data/lib/assaydepot/event.rb

@@ -0,0 +1,21 @@
+require "openssl"
+
+module AssayDepot
+  class Webhook
+
+    def self.construct_event(payload, signature_header, endpoint_secret)
+      sig_hash = {}
+
+      # get t=, v0=, v1= components of the signature
+      signature_header.split(',').each do |str|
+        sig_hash[str.split('=')[0]] = str.split('=')[1]
+      end
+
+      mac = OpenSSL::HMAC.hexdigest("SHA256", "#{sig_hash["t"]}0123456789abcdefghijklmnopqrstuvwxyz", payload)
+      raise AssayDepot::SignatureVerificationError.new "Event (#{Rails.env}) not properly signed." if Rails.env == 'test' || Rails.env == 'development' && mac != sig_hash["v0"]
+      mac = OpenSSL::HMAC.hexdigest("SHA256", "#{sig_hash["t"]}#{endpoint_secret}", payload)
+      raise AssayDepot::SignatureVerificationError.new if Rails.env != 'test' && Rails.env != 'development' && mac != sig_hash["v1"]
+      raise AssayDepot::SignatureVerificationError.new "Invalid timestamp." if sig_hash["t"].to_i < 5.minutes.ago.to_i
+    end
+  end
+end

data/lib/assaydepot/model.rb

@@ -1,109 +1,214 @@
+require 'forwardable'
 module AssayDepot
-  module Model
+  module DatabaseModel
     module ClassMethods
+      def all(options = {})
+        self.new.all(options)
+      end
+    end
+
+    def self.included(base)
+      base.include AssayDepot::Model
+      base.extend AssayDepot::Model::ClassMethods
+      base.extend ClassMethods
+    end
+
+    def all(options = {})
+      result = self.clone
+      result.internal_options = options
+      result
+    end
+
+    # Overridden from Model
+    def internal_results
+      unless @internal_results
+        @internal_results = JSON.parse(Client.new(endpoint: self.class.endpoint(nil)).get(params: @internal_options))
+      end
+      @internal_results
+    end
+  end
+
+  module SearchModel
+    module ClassMethods
+      # find and where to modify params
       def find(query)
         self.new.find(query)
       end
+
       def where(conditions={})
         self.new.where(conditions)
       end
-      def get(id)
-        Client.new(:search_type => search_type).get(id)
-      end
     end
 
     def self.included(base)
+      base.extend AssayDepot::Model::ClassMethods
       base.extend ClassMethods
-      base.extend Forwardable
-      base.def_delegators  :private_results, 
-                      :each, 
-                      :[], 
-                      :count, 
-                      :collect, 
-                      :map,
-                      :tap, 
-                      :<=>, 
-                      :compact, 
-                      :each_index, 
-                      :each_with_index, 
-                      :empty?, 
-                      :flatten, 
-                      :include?, 
-                      :index, 
-                      :length, 
-                      :first, 
-                      :last, 
-                      :keep_if,
-                      :reject,
-                      :reverse
+      base.include AssayDepot::Model
+      base.include AssayDepot::Pageable
 
       attr_accessor :search_query
       attr_accessor :search_facets
-      attr_accessor :search_options
+    end
 
-      def initialize(options={})
-        @search_query = options[:search_query] || ""
-        @search_facets = options[:search_facets] || {}
-        @search_options = options[:search_options] || {:page => 1}
-      end
+    def initialize(options={})
+      @internal_options = options[:search_options] || { }
+      @search_query = options[:search_query] || ""
+      @search_facets = options[:search_facets] || { }
+    end
 
-      def initialize_copy(source)  
-        super
-        @search_query = @search_query.dup
-        @search_facets = @search_facets.dup
-      end
+    def facets
+      internal_results["facets"]
+    end
 
-      def query_time
-        search_results["query_time"]
-      end
-      def total
-        search_results["total"]
-      end
-      def page
-        search_results["page"]
-      end
-      def per_page
-        search_results["per_page"]
-      end
-      def facets
-        search_results["facets"]
+    def find(query)
+      result = self.clone
+      result.search_query = query
+      result
+    end
+
+    def where(conditions={})
+      result = self.clone
+      result.search_facets = self.search_facets ? self.search_facets.merge(conditions) : conditions
+      result
+    end
+
+    # Overridden from Model
+    def internal_results
+      unless @internal_results
+        results = Client.new(endpoint: self.class.endpoint(nil)).search(query: search_query, facets: search_facets, params: internal_options)
+        @internal_results = JSON.parse(results)
       end
+      @internal_results
+    end
+  end
 
-      def page(page_num)
-        options( { "page" => page_num } )
+  module Model
+    module ClassMethods
+      def get_token(client_id, client_secret, site)
+        response = Client.new.request(AssayDepot::TokenAuth.endpoint(site), {}, {}, {:username => client_id, :password => client_secret})
+        response[AssayDepot::TokenAuth.ref_name]
       end
 
-      def per_page(page_size)
-        options( { "per_page" => page_size } )
+      def get_endpoint(id, endpoint, format = "json")
+        id = id[0] if id && id.kind_of?(Array)
+        id ? "#{endpoint}/#{id}.#{format}" : "#{endpoint}.#{format}"
       end
 
-      def find(query)
-        result = self.clone
-        result.search_query = search_query
+      # HTTP request verbs
+      # optional "id" followed by optional hash
+      def get(id: nil, params: {}, format: "json")
+        puts "GET id #{id}, params #{params}" if ENV["DEBUG"] == "true"
+        result = Client.new(endpoint: endpoint(id, format)).get(params: params)
+        return JSON.parse(result) if format == "json"
         result
       end
 
-      def where(conditions={})
-        result = self.clone
-        result.search_facets = self.search_facets ? self.search_facets.merge(conditions) : conditions
+      def put(id: nil, body: nil, params: {}, format: "json")
+        puts "PUT id #{id}, body #{body.to_s}, params #{params}" if ENV["DEBUG"] == "true"
+        result = Client.new(endpoint: endpoint(id, format)).put( body: body, params: params )
+        return JSON.parse(result) if format == "json"
         result
       end
 
-      def options(options={})
-        result = self.clone
-        result.search_options = self.search_options ? self.search_options.merge(options) : options
+      def patch(id: nil, body: nil, params: {}, format: "json")
+        puts "PATCH id #{id}, body #{body.to_s}, params #{params}" if ENV["DEBUG"] == "true"
+        result = Client.new(endpoint: endpoint(id, format)).put( body: body, params: params )
+        return JSON.parse(result) if format == "json"
         result
       end
 
-      def private_results
-        search_results[self.class.ref_name]
+      def post(id: nil, body: nil, params: {}, format: "json")
+        puts "POST id #{id}, body #{body.to_s}, params #{params}" if ENV["DEBUG"] == "true"
+        result = Client.new(endpoint: endpoint(id, format)).post( body: body, params: params )
+        return JSON.parse(result) if format == "json"
+        result
       end
-      def search_results
-        unless @search_results
-          @search_results = Client.new(:search_type => self.class.search_type).search(search_query, search_facets, search_options)
-        end
-        @search_results
+
+      def delete(id: nil, body: nil, params: {}, format: "json")
+        puts "DELETE id #{id}, params #{params}" if ENV["DEBUG"] == "true"
+        result = Client.new(endpoint: endpoint(id, format)).delete(params: params)
+        return JSON.parse(result) if format == "json"
+        result
       end
     end
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.extend Forwardable
+      base.def_delegators  :private_results,
+                      :each,
+                      :[],
+                      :count,
+                      :collect,
+                      :map,
+                      :tap,
+                      :<=>,
+                      :compact,
+                      :each_index,
+                      :each_with_index,
+                      :empty?,
+                      :flatten,
+                      :include?,
+                      :index,
+                      :length,
+                      :first,
+                      :last,
+                      :keep_if,
+                      :reject,
+                      :reverse
+
+      attr_accessor :internal_options
+    end
+
+    def initialize(options={})
+      @internal_options = options[:search_options] || { }
+    end
+
+    def initialize_copy(source)
+      super
+      @search_query = @search_query.dup
+      @search_facets = @search_facets.dup
+    end
+
+    def query_time
+      internal_results["query_time"]
+    end
+
+    def total
+      internal_results["total"]
+    end
+
+    def options(options={})
+      result = self.clone
+      result.internal_options = self.internal_options ? self.internal_options.merge(options) : options
+      result
+    end
+
+    def private_results
+      internal_results[self.class.ref_name]
+    end
+
+    # def internal_results
+    #   # To be overridden
+    #   # If I leave this method in, it gets called, possibly a problem with the order of inclusion
+    # end
+  end
+
+  module Pageable
+    def page
+      internal_results["page"]
+    end
+
+    def per_page
+      internal_results["per_page"]
+    end
+
+    def page(page_num)
+      options( { "page" => page_num } )
+    end
+
+    def per_page(page_size)
+      options( { "per_page" => page_size } )
+    end
   end
-end
+end

data/lib/assaydepot/version.rb

@@ -1,3 +1,3 @@
 module AssayDepot
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/spec/assaydepot_backoffice_spec.rb

@@ -0,0 +1,30 @@
+require 'assaydepot'
+require 'dotenv'
+Dotenv.load
+
+describe AssayDepot do
+  context "scientist_api backoffice tests" do
+    before(:all) do
+      AssayDepot.configure do |config|
+        config.access_token = ENV['BACKOFFICE_ACCESS_TOKEN']
+        config.url = "#{ENV['BACKOFFICE_SITE']}/api/v2"
+      end
+    end
+
+    context "info" do
+      let(:info) { AssayDepot::Info.get() }
+
+      it "info version V2" do
+        info["api_version"].should == "V2"
+      end
+    end
+
+    context "quoted wares" do
+      let(:qw) { AssayDepot::QuotedWare.get() }
+
+      it "get all quoted wares" do
+        qw.is_a?(Array).should == true
+      end
+    end
+  end
+end

data/spec/assaydepot_spec.rb

@@ -0,0 +1,124 @@
+require 'assaydepot'
+require 'dotenv'
+Dotenv.load
+
+describe AssayDepot do
+  context "when accessing the api via token client credentials" do
+    before(:all) do
+      AssayDepot.configure do |config|
+        config.access_token = ENV['ACCESS_TOKEN']
+        config.url = "#{ENV['SITE']}/api/v2"
+      end
+    end
+
+    context "and searching for wares matching \"antibody\"" do
+      let(:wares) { AssayDepot::Ware.find("antibody") }
+
+      it "should return a Ware object" do
+        wares.class.should == AssayDepot::Ware
+      end
+
+      it "should return some wares" do
+        wares.total.should > 1
+      end
+
+      context "and getting the details for the first ware" do
+        let(:ware_result) { AssayDepot::Ware.get(id: wares.first["id"]) }
+
+        it "should have a ware" do
+          ware_result["ware"].should_not be_nil
+        end
+
+        it "should have a description" do
+          ware_result["ware"]["description"].should_not be_nil
+        end
+      end
+    end
+
+    context "when searching for wares of type CustomService" do
+      let(:wares) { AssayDepot::Ware.where(:ware_type => "CustomService") }
+
+      it "should return facets" do
+        wares.facets.should_not be_empty
+      end
+
+      it "should include the source facet" do
+        wares.facets.should include("source")
+      end
+
+      it "should include the ware_type facet" do
+        wares.facets.should include("ware_type")
+      end
+
+      # RR: replaced "available_provider_names"
+      it "should include the technology facet" do
+        wares.facets.should include("technology")
+      end
+
+      it "should include the certifications facet" do
+        wares.facets.should include("certifications")
+      end
+
+      it "should include the countries facet" do
+        wares.facets.should include("countries")
+      end
+
+      it "should include the protein_type facet" do
+        wares.facets.should include("protein_type")
+      end
+
+      it "should include the clonality facet" do
+        wares.facets.should include("clonality")
+      end
+
+      it "should include the cell_source facet" do
+        wares.facets.should include("cell_source")
+      end
+
+      it "should include the species facet" do
+        wares.facets.should include("species")
+      end
+
+      it "should include the tissue facet" do
+        wares.facets.should include("tissue")
+      end
+    end
+
+    context "when searching for wares using a chained query" do
+      let(:wares) { AssayDepot::Ware.where(:ware_type => "CustomService").where(:source => "central-staging") }
+
+      it "should return wares" do
+        wares.total.should > 0
+      end
+
+      it "the ware's name should be available" do
+        wares.first["name"].should_not be_nil
+      end
+    end
+
+    context "and searching for providers that start with the letter a" do
+      let(:starts_with) {AssayDepot::Provider.get()["facets"]["starts_with"]["buckets"].first}
+      let(:providers) { AssayDepot::Provider.where(:starts_with => starts_with["key"]).per_page(50) }
+
+      it "should return a Provider object" do
+        providers.class.should == AssayDepot::Provider
+      end
+
+      it "should return some providers" do
+        providers.total.should == starts_with["doc_count"]
+      end
+
+      context "and getting the details for the first provider" do
+        let(:provider_result) { AssayDepot::Provider.get(id: providers.first["id"]) }
+
+        it "have a provider" do
+          provider_result["provider"].should_not be_nil
+        end
+
+        it "have keywords" do
+          expect(provider_result['provider']).to have_key('keywords')
+        end
+      end
+    end
+  end
+end