nexosis_api 2.4.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d289d314e46f48ce9d901cc1d179dc8ba1c1c1a59a3cb7d7bd82a0f2f264ced1
-  data.tar.gz: 5241b8b07d590ac5578c32e619054e2eb4fe944e0a217b9486daa84a748aa9d6
+  metadata.gz: ab792a54e07188d8425d45c39c7b64f3862f009ec1f83c30531057411091a911
+  data.tar.gz: c252e1fdd7f2be4c0a1bc6bb91ce0b5cf2f75de33db70f7ecd48e3e62d0c17e6
 SHA512:
-  metadata.gz: bc11eaf8123053d1ffaa2414b495567bb2e5570fee70bb17894bb4c24b20410b458e5cc15b9994d8b20644179c8ae5305fc7bae8a380118886ebeb2f031b0e4a
-  data.tar.gz: b705e940d7bf85bfd33a9d19fe6611a52e5b83efe109b1b84f682fd4e9591949683aa477eeebdfc5a993c228749f316ecdddfe85f3e1ef333e71b41fd1f1adf6
+  metadata.gz: d5955b865d93589337ef1ba7f4c4b132adbf2d1513216a1140d673187d49479573eb5021342666a0a653c93cbd8ac00bbbb28f52c8b6161bbfdd64606f7b169c
+  data.tar.gz: 5c569ddb22bf8d748dd3b53e72819e1358b0a829789ad68167974676f1ad542b9d8c0244fef4bcc1875fd4358f1d9d22bf038f5abbd4aad6f694dc34a0d48fb4

data/lib/nexosis_api/client.rb

@@ -20,6 +20,7 @@ require 'nexosis_api/impact_metric'
 require 'nexosis_api/imports_response'
 require 'nexosis_api/join'
 require 'nexosis_api/link'
+require 'nexosis_api/list_queries'
 require 'nexosis_api/message'
 require 'nexosis_api/metric'
 require 'nexosis_api/model_summary'
@@ -31,6 +32,7 @@ require 'nexosis_api/session_response'
 require 'nexosis_api/session_result'
 require 'nexosis_api/session_selection_metrics'
 require 'nexosis_api/session'
+require 'nexosis_api/sort_order'
 require 'nexosis_api/time_interval'
 require 'nexosis_api/timeseries_outliers'
 require 'nexosis_api/view_definition'

data/lib/nexosis_api/client/datasets.rb

@@ -28,19 +28,15 @@ module NexosisApi
 
       # Gets the list of data sets that have been saved to the system, optionally filtering by partial name match.
       #
-      # @param partial_name [String] if provided, all datasets returned will contain this string
-      # @param page [int] page number for items in list
-      # @param page_size [int] number of items in each page
+      # @param dataset_list_query [NexosisApi::DatasetListQuery] Defines options for limiting list query results.
       # @return [NexosisApi::PagedArray of NexosisApi::DatasetSummary] array of datasets found
-      # @since 1.4 - added paging parameters
-      def list_datasets(partial_name = '', page = 0, page_size = 50)
+      # @since 1.4.0 - added paging parameters
+      # @since 2.5.0 - added multiple query options
+      # @since 3.0.0 - use list query instead of differing parms
+      # @note a default list query will use page=0 and pageSize=50 in the query
+      def list_datasets(dataset_list_query = NexosisApi::DatasetListQuery.new)
         list_dataset_url = '/data'
-        query = {
-          page: page,
-          pageSize: page_size
-        }
-        query['partialName'] = partial_name unless partial_name.empty?
-        response = self.class.get(list_dataset_url, headers: @headers, query: query)
+        response = self.class.get(list_dataset_url, headers: @headers, query: dataset_list_query.query_parameters)
         if response.success?
           NexosisApi::PagedArray.new(response.parsed_response,
                                      response.parsed_response['items']

data/lib/nexosis_api/client/imports.rb

@@ -8,19 +8,12 @@ module NexosisApi
 
       # List all existing import requests
       #
-      # @param dataset_name [String] optional name filter of dataset which was imported
-      # @param page [int] page number for items in list
-      # @param page_size [int] number of items in each page
+      # @param import_list_query [NexosisApi::ImportListQuery] options to limit the query results
       # @return [NexosisApi::PagedArray of NexosisApi::ImportsResponse]
       # @since 1.4 added paging parameters
-      def list_imports(dataset_name = '', page = 0, page_size = 50)
+      def list_imports(import_list_query = NexosisApi::ImportListQuery.new)
         imports_url = '/imports'
-        query = {
-          dataSetName: dataset_name,
-          page: page,
-          pageSize: page_size
-        }
-        response = self.class.get(imports_url, headers: @headers, query: query)
+        response = self.class.get(imports_url, headers: @headers, query: import_list_query.query_parameters)
         if (response.success?)
           NexosisApi::PagedArray.new(response.parsed_response,
                                      response.parsed_response['items']

data/lib/nexosis_api/client/models.rb

@@ -5,24 +5,14 @@ module NexosisApi
     module Models
       # List all models created in your company, optionally filtered by query parameters
       #
-      # @param datasource_name [String] optionally limit to those
-      # models created for this data source name.
-      # @param query_options [Hash] limit by dates: begin_date and/or end_date
+      # @param model_list_query [NexosisApi::ModelListQuery] optionally limit query results by the given parameters
       # @note - query options dates can either be ISO 8601 compliant strings or Date objects.
       # @return [NexosisApi::PagedArray of NexosisApi::ModelSummary] - all models available within the query parameters
       # @raise [NexosisApi::HttpException]
-      def list_models(datasource_name = nil, page = 0, page_size = 50, query_options = {})
+      # @since 3.0.0 - all query parameters use list query class
+      def list_models(model_list_query = NexosisApi::ModelListQuery.new)
         model_url = '/models'
-        query = {
-          page: page,
-          pageSize: page_size
-        }
-        unless query_options.empty?
-          query.store('createdBeforeDate', query_options['end_date']) unless query_options['end_date'].nil?
-          query.store('createdAfterDate', query_options['begin_date']) unless query_options['begin_date'].nil?
-        end
-        query.store('dataSourceName', datasource_name) unless datasource_name.nil?
-        response = self.class.get(model_url, headers: @headers, query: query)
+        response = self.class.get(model_url, headers: @headers, query: model_list_query.query_parameters)
         raise HttpException.new("There was a problem listing models: #{response.code}.",
                                 "listing models with data source name #{datasource_name}",
                                 response) unless response.success?

data/lib/nexosis_api/client/sessions.rb

@@ -10,29 +10,20 @@ module NexosisApi
 
       # List sessions previously submitted
       #
-      # @param query_options [Hash] optionally provide query parameters to limit the search of sessions. 
-      # @param page [Integer] optionally provide a page number for paging. Defaults to 0 (first page).
-      # @param pageSize [Integer] optionally provide a page size to limit the total number of results. Defaults to 50, max 1000
+      # @param session_list_query [NexosisApi::SessionListQuery] optionally provide query parameters to limit the search of sessions.
       # @return [NexosisApi::PagedArray of NexosisApi::SessionResponse] with all sessions matching the query or all if no query
       # @raise [NexosisApi::HttpException]
-      # @note query parameters hash members are dataset_name, event_name, requested_before_date, and requested_after_date. 
-      #    After and before dates refer to the session requested date.
+      # @note query parameters hash members are dataset_name, event_name, model_id, 
+      #   sort_by, sort_order, requested_before_date, and requested_after_date. 
+      #   After and before dates refer to the session requested date.
       # @example query for just one dataset
       #   sessions = NexosisApi.client.list_sessions :dataset_name => 'MyDataset'
-      def list_sessions(query_options = {}, page = 0, pageSize = 50)
+      # @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/sessions-list-all?
+      def list_sessions(session_list_query = NexosisApi::SessionListQuery.new)
         sessions_url = '/sessions'
-        query = {
-          'dataSetName' => query_options[:dataset_name],
-          'eventName' => query_options[:event_name],
-          'requestedAfterDate' => query_options[:requested_after_date],
-          'requestedBeforeDate' => query_options[:requested_before_date],
-          'type' => query_options[:type],
-          'page' => page,
-          'pageSize' => pageSize
-        }
-        response = self.class.get(sessions_url, headers: @headers, query: query)
+        response = self.class.get(sessions_url, headers: @headers, query: session_list_query.query_parameters)
         raise HttpException.new('Could not retrieve sessions',
-                                "Get all sessions with query #{query_options}",
+                                "Get all sessions with query #{session_list_query.query_parameters}",
                                 response) unless response.success?
         NexosisApi::PagedArray.new(response.parsed_response, response.parsed_response['items'].map do |session_hash|
           response_hash = { 'session' => session_hash }.merge(response.headers)

data/lib/nexosis_api/list_queries.rb

@@ -0,0 +1,198 @@
+module NexosisApi
+  require 'date'
+  # Class to hold general query options for list requests
+  # @since 3.0.0
+  class ListQuery
+    def initialize(options = { 'page_number': 0, 'page_size': 50 }, *additional_keys)
+      assert_valid_keys(options, :page_number, :page_size, :sort_order, :sort_by, additional_keys)
+      @page_number = options.key?(:page_number) ? options[:page_number] : 0
+      @page_size = options.key?(:page_size) ? options[:page_size] : 50
+      @sort_order = NexosisApi::SortOrder.const_get(options[:sort_order].upcase) if options.key? :sort_order
+      @sort_by = options[:sort_by] if options.key? :sort_by
+    end
+
+    def to_hash
+      query = {
+        'page': @page_number,
+        'pageSize': @page_size
+      }
+      query.store(:sortOrder, @sort_order) unless @sort_order.nil?
+      query.store(:sortBy, @sort_by) unless @sort_by.nil?
+      query
+    end
+
+    # Count of results to retrieve in each page (max 1000).
+    # @return [Integer]
+    attr_accessor :page_size
+
+    # zero-based page number of results to retrieve
+    # @return [Integer]
+    attr_accessor :page_number
+
+    # Direction to sort the results.
+    # @return [NexosisApi::SortOrder]
+    attr_accessor :sort_order
+
+    # The name of an entity property to sort by
+    # @return [String]
+    # @note - each entity has different possibilities. See the api doc links on each list type for more information.
+    attr_accessor :sort_by
+
+    private
+
+    def date_string(date_field)
+      raise ArgumentError, 'date_field was not provided and is not optional ' if date_field.to_s.empty?
+      date = DateTime.parse(date_field.to_s)
+      date.strftime('%FT%T%:z')
+    end
+
+    def assert_valid_keys(options, *valid_keys)
+      valid_keys.flatten!
+      options.keys.each do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+        end
+      end
+    end
+  end
+
+  # class to hold the query options for list datasets
+  # @since 3.0.0
+  # @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/datasets-list-all?
+  # @note - sort by properties include dataSetName, dataSetSize, rowCount, dateCreated, and lastModified
+  class DatasetListQuery < ListQuery
+    def initialize(options = {})
+      
+      @partial_name = options[:partial_name] if options.key? :partial_name
+      super(options, :partial_name)
+    end
+
+    # A hash suitable for using as the query portion of an HTTP request to the API
+    # @return [Hash]
+    def query_parameters
+      parm_hash = {}
+      parm_hash.store(:partialName, @partial_name) unless @partial_name.nil?
+      self.to_hash.merge(parm_hash)
+    end
+    # The name or part of a name by which to limit the list results.
+    # @return [String]
+    attr_accessor :partial_name
+  end
+
+  # class to hold the query options for list datasets
+  # @since 3.0.0
+  # @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/sessions-list-all?
+  # @note sort by properties include id, name, type, status, dataSourceName, and requestedDate
+  class SessionListQuery < ListQuery
+    def initialize(options = {})
+      @datasource_name = options[:datasource_name] if options.key? :datasource_name
+      @event_name = options[:event_name] if options.key? :event_name
+      @model_id = options[:model_id] if options.key? :model_id
+      @requested_after_date = options[:requested_after_date] if options.key? :requested_after_date
+      @requested_before_date = options[:requested_before_date] if options.key? :requested_before_date
+      super(options, :datasource_name, :event_name, :model_id, :requested_after_date, :requested_before_date)
+    end
+
+    # A hash suitable for using as the query portion of an HTTP request to the API
+    # @return [Hash]
+    def query_parameters
+      parm_hash = {}
+      parm_hash.store(:dataSourceName, @datasource_name) unless @datasource_name.nil?
+      parm_hash.store(:eventName, @event_name) unless @event_name.nil?
+      parm_hash.store(:modelId, @model_id) unless @model_id.nil?
+      parm_hash.store(:requestedAfterDate, date_string(@requested_after_date)) unless @requested_after_date.nil?
+      parm_hash.store(:requestedBeforeDate, date_string(@requested_before_date)) unless @requested_before_date.nil?
+      self.to_hash.merge(parm_hash)
+    end
+
+    # Limits sessions to those for a particular data source
+    # @return [String]
+    attr_accessor :datasource_name
+
+    # Limits impact sessions to those for a particular event
+    # @return [String]
+    attr_accessor :event_name
+
+    # Limits model-building sessions to those that built the specified model
+    # @return [String]
+    attr_accessor :model_id
+
+    # Format - date-time (as date-time in ISO8601). Limits sessions to those requested on or after the specified date
+    # @return [String]
+    attr_accessor :requested_after_date
+
+    # Format - date-time (as date-time in ISO8601). Limits sessions to those requested on or before the specified date
+    # @return [String]
+    attr_accessor :requested_before_date
+  end
+
+  # class to hold the query options for list models
+  # @since 3.0.0
+  # @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/models-list-all?
+  # @note sort by properties include id, modelName, dataSourceName, type, createdDate, and lastUsedDate
+  class ModelListQuery < ListQuery
+    def initialize(options = {})
+      @datasource_name = options[:datasource_name] if options.key? :datasource_name
+      @created_after_date = options[:created_after_date] if options.key? :created_after_date
+      @created_before_date = options[:created_before_date] if options.key? :created_before_date
+      super(options, :datasource_name, :created_after_date, :created_before_date)
+    end
+
+    # A hash suitable for using as the query portion of an HTTP request to the API
+    # @return [Hash]
+    def query_parameters
+      parm_hash = {}
+      parm_hash.store(:dataSourceName, @datasource_name) unless @datasource_name.nil?
+      parm_hash.store(:createdAfterDate, date_string(@created_after_date)) unless @created_after_date.nil?
+      parm_hash.store(:createdBeforeDate, date_string(@created_before_date)) unless @created_before_date.nil?
+      self.to_hash.merge(parm_hash)
+    end
+
+    # Limits models to those for a particular data source
+    # @return [String]
+    attr_accessor :datasource_name
+
+    # Format - date-time (as date-time in ISO8601). Limits models to those created on or after the specified date
+    # @return [String]
+    attr_accessor :created_after_date
+
+    # Format - date-time (as date-time in ISO8601). Limits models to those created on or before the specified date
+    # @return [String]
+    attr_accessor :created_before_date
+  end
+
+  # class to hold the query options for list imports
+  # @since 3.0.0
+  # @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/imports-list-imports?
+  # @note sort by properties include id, dataSetName, requestedDate, and currentStatusDate
+  class ImportListQuery < ListQuery
+    def initialize(options = {})
+      @dataset_name = options[:dataset_name] if options.key? :dataset_name
+      @requested_after_date = options[:requested_after_date] if options.key? :requested_after_date
+      @requested_before_date = options[:requested_before_date] if options.key? :requested_before_date
+      super(options, :dataset_name, :requested_after_date, :requested_before_date)
+    end
+
+    # A hash suitable for using as the query portion of an HTTP request to the API
+    # @return [Hash]
+    def query_parameters
+      parm_hash = {}
+      parm_hash.store(:dataSourceName, @dataset_name) unless @dataset_name.nil?
+      parm_hash.store(:requestedAfterDate, date_string(@requested_after_date)) unless @requested_after_date.nil?
+      parm_hash.store(:requestedBeforeDate, date_string(@requested_before_date)) unless @requested_before_date.nil?
+      self.to_hash.merge(parm_hash)
+    end
+
+    # Limits imports to those for a particular dataset
+    # @return [String]
+    attr_accessor :dataset_name
+
+    # Format - date-time (as date-time in ISO8601). Limits imports to those requested on or after the specified date
+    # @return [String]
+    attr_accessor :requested_after_date
+
+    # Format - date-time (as date-time in ISO8601). Limits imports to those requested on or before the specified date
+    # @return [String]
+    attr_accessor :requested_before_date
+  end
+end

data/lib/nexosis_api/sort_order.rb

@@ -0,0 +1,11 @@
+module NexosisApi
+  # Constants for list query sort order
+  # @since 3.0.0
+  module SortOrder
+    # Order results ascending according to type sort
+    ASC = :string
+
+    # Order results descending according to type sort
+    DESC = :string
+  end
+end

data/nexosisapi.gemspec

@@ -16,6 +16,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.3.0'
   spec.summary = "Ruby client for working with the Nexosis API"
-  spec.version = '2.4.1'
+  spec.version = '3.0.0'
   spec.metadata["yard.run"] = "yri"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexosis_api
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Nexosis,Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-06 00:00:00.000000000 Z
+date: 2018-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/nexosis_api/imports_response.rb
 - lib/nexosis_api/join.rb
 - lib/nexosis_api/link.rb
+- lib/nexosis_api/list_queries.rb
 - lib/nexosis_api/message.rb
 - lib/nexosis_api/metric.rb
 - lib/nexosis_api/model_summary.rb
@@ -87,6 +88,7 @@ files:
 - lib/nexosis_api/session_response.rb
 - lib/nexosis_api/session_result.rb
 - lib/nexosis_api/session_selection_metrics.rb
+- lib/nexosis_api/sort_order.rb
 - lib/nexosis_api/time_interval.rb
 - lib/nexosis_api/timeseries_outliers.rb
 - lib/nexosis_api/view_data.rb