cts-mpx 1.0.1

data/lib/cts/mpx/query.rb

@@ -0,0 +1,115 @@
+module Cts
+  module Mpx
+    # Query method, allows you to build and send a query to the data services.
+    # @attribute account
+    #   @return [String] account account context, can be id or name
+    # @attribute endpoint
+    #   @return [String] endpoint of the service
+    # @attribute extra_path
+    #   @return [String] any extra_path
+    # @attribute fields
+    #   @return [String] Fields to gather
+    # @attribute ids
+    #   @return [Array] Ids to search through
+    # @attribute page
+    #   @return [Page] Page of the search results
+    # @attribute query
+    #   @return [Hash] Additional query to add
+    # @attribute range
+    #   @return [String] String range in the service shell style
+    # @attribute return_count
+    #   @return [Boolean] should this query return count (generally, no)
+    # @attribute return_entries
+    #   @return [Boolean] should this query return entries
+    # @attribute service
+    #   @return [String] service the query is for
+    # @attribute sort
+    #   @return [String] string to sort in the service shell style
+    class Query
+      extend Creatable
+      attr_accessor :sort
+
+      attribute name: 'account', kind_of: String
+      attribute name: 'endpoint', kind_of: String
+      attribute name: 'extra_path', kind_of: String
+      attribute name: 'fields', kind_of: String
+      attribute name: 'ids', kind_of: Array
+      attribute name: 'page', kind_of: Driver::Page
+      attribute name: 'query', kind_of: Hash
+      attribute name: 'range', kind_of: String
+      attribute name: 'return_count', kind_of: FalseClass
+      attribute name: 'return_entries', kind_of: TrueClass
+      attribute name: 'service', kind_of: String
+      attribute name: 'sort', kind_of: String
+
+      # List of attributes availble
+      # @return [Symbol[]]
+      def attributes
+        %i[account endpoint extra_path fields ids query range return_count return_entries service sort]
+      end
+
+      # Instiatiate a page and query, set return's to false.
+      def initialize
+        @page = Driver::Page.new
+
+        @return_entries = true
+        @return_count = false
+        @query = {}
+      end
+
+      # List of entries created from the page
+      # @return [Entries] populated Entries object
+      def entries
+        Entries.create_from_page @page
+      end
+
+      # Run the query
+      # @param [User] user user to make calls with
+      # @return [Self]
+      def run(user: nil)
+        Driver::Helpers.required_arguments %i[user], binding
+        Driver::Exceptions.raise_unless_argument_error? user, User
+
+        raise "service must be set" unless service
+        raise "endpoint must be set" unless endpoint
+
+        response = Services::Data.get params.merge(user: user)
+        @page = response.page
+        self
+      end
+
+      # Hash representation of the query data.  Has a key for params and for entries.
+      # @param [Boolean] include_entries include the entries array or not
+      # @return [Hash]
+      def to_h(include_entries: true)
+        h = {
+          params: params
+        }
+        h[:entries] = entries.to_h if include_entries
+        h
+      end
+
+      private
+
+      # List of parameters that are currently set in the query
+      # @return [Hash]
+      def params
+        output = {}
+
+        attributes.each do |attribute|
+          output.store attribute, instance_variable_get("@#{attribute}") unless instance_variable_get("@#{attribute}").nil?
+        end
+
+        unless output[:return_count].nil?
+          output[:count] = output.delete :return_count
+        end
+
+        unless output[:return_entries].nil?
+          output[:entries] = output.delete :return_entries
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/cts/mpx/registry.rb

@@ -0,0 +1,60 @@
+module Cts
+  module Mpx
+    # Set of procedural functions to interact with the Registry.
+    module Registry
+      module_function
+
+      # Collection of domains stored in memory
+      # @return [Hash] key is an account_id, value is a hash of results
+      def domains
+        @domains
+      end
+
+      # Call fetch and store domain in sequence.
+      # @param [User] user user to make calls with
+      # @param [String] account_id long form account id (ownerId)
+      # @raise (see #fetch_domain)
+      # @return [Hash] hash of the newly fetched domain
+      def fetch_and_store_domain(user, account_id = 'urn:theplatform:auth:root')
+        result = fetch_domain user, account_id
+        store_domain result, account_id
+        domains[account_id]
+      end
+
+      # Fetch a domain from the registry.
+      # @param [User] user user to make calls with
+      # @param [String] account_id long form account id (ownerId)
+      # @raise [ArgumentError] if the user is not a user object
+      # @raise [ArgumentError] if the account_id is not valid
+      # @return [Hash] hash of the newly fetched domain
+      def fetch_domain(user, account_id = 'urn:theplatform:auth:root')
+        return domains['urn:theplatform:auth:root'] if account_id == 'urn:theplatform:auth:root'
+        Driver::Exceptions.raise_unless_argument_error?(user, 'User') { user.is_a? User }
+        Driver::Exceptions.raise_unless_argument_error?(account_id, 'account_id') { Validators.account_id? account_id }
+        user.token!
+
+        response = Services::Web.post user: user, service: 'Access Data Service', endpoint: 'Registry', method: 'resolveDomain', arguments: { 'accountId' => account_id }
+        response.data['resolveDomainResponse']
+      end
+
+      # Store the domain in memory
+      # @param [Hash] data collection received from Registry
+      # @param [String] account_id long form account id (ownerId)
+      # @raise [ArgumentError] if the data is not a valid hash
+      # @raise [ArgumentError] if the account_id is not valid
+      # @return [Void]
+      def store_domain(data, account_id = 'urn:theplatform:auth:root')
+        raise ArgumentError, "#{account_id} is not a valid account_id" unless Validators.account_id? account_id
+        raise ArgumentError, "#{data} is not a valid Hash" unless data.is_a? Hash
+        @domains.store account_id, data
+        nil
+      end
+
+      # find and store the root registry from the US
+      def initialize
+        @domains = {}
+        store_domain(Driver.load_json_file("#{Driver.config_dir}/root_registry_sea1.json")['resolveDomainResponse'], 'urn:theplatform:auth:root')
+      end
+    end
+  end
+end

data/lib/cts/mpx/service.rb

@@ -0,0 +1,70 @@
+module Cts
+  module Mpx
+    module Driver
+      # Class to wrap a service and what is available to interact with
+      # @attribute name
+      #   @return [String] Title of the service, must be identical to the registry entry
+      # @attribute uri_hint
+      #   @return [String] partial string of the uri, this allows for a reverse lookup from url
+      # @attribute path
+      #   @return [String] prepended path statement attached per service
+      # @attribute form
+      #   @return [String] type of http schema to use, can be json or cjson
+      # @attribute schema
+      #   @return [String] version of the service schema
+      # @attribute search_schema
+      #   @return [String] version of the search schema
+      # @attribute read_only
+      #   @return [Boolean] is this a read only service or not
+      # @attribute endpoints
+      #   @return [Array] Available endpoints to communicate with
+      # @attribute type
+      #   @return [String] the type of service this is
+      class Service
+        attr_accessor :name
+        attr_accessor :uri_hint
+        attr_accessor :path
+        attr_accessor :form
+        attr_accessor :schema
+        attr_accessor :search_schema
+        attr_accessor :read_only
+        attr_accessor :endpoints
+        attr_accessor :type
+
+        # Set all values to something
+        def initialize
+          @name = ""
+          @uri_hint = ""
+          @path = ""
+          @form = ""
+          @schema = ""
+          @search_schema = ""
+          @read_only = false
+          @endpoints = []
+          @type = nil
+          @url = nil
+        end
+
+        # Return a given url of a service, will look in the local registry
+        # @param [String] account_id long form account id (ownerId)
+        # @return [String] the url string or nil if none available
+        def url(account_id = 'urn:theplatform:auth:root')
+          Exceptions.raise_unless_account_id account_id
+          reg = Registry.domains[account_id]
+          return reg[name] if reg
+          nil
+        end
+
+        # checks if we have a given entry in the local registry
+        # @param [String] account_id long form account id (ownerId)
+        # @return [Boolean] true if it is available, false if it is not
+        def url?(account_id = 'urn:theplatform:auth:root')
+          Exceptions.raise_unless_account_id account_id
+          u = url account_id
+          return true if u
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/services.rb

@@ -0,0 +1,113 @@
+module Cts
+  module Mpx
+    # Container style module for the collection of services available.
+    module Services
+      module_function
+
+      # Addressable method, indexed by service title
+      # @param [String] key service title to look up the service object
+      # @raise [ArgumentError] if the key is not a service name
+      # @raise [ArgumentError] if the key is not a string
+      # @return [Service[]] if no key, return the entire array of services
+      # @return [Service] a service
+      def [](key = nil)
+        return @services unless key
+        raise 'key must be a string' unless key.is_a? String
+        service = @services.find { |e| e.name == key }
+        raise "#{key} must be a service name." unless service
+        service
+      end
+
+      # return a service from the supplied url
+      # @param [String] url url to parse
+      # @return [Hash] including service and endpoint as string.
+      def from_url(url)
+        service = Services[].find { |s| url.include? s.uri_hint if s.uri_hint }
+        return nil unless service
+
+        {
+          service:  service.name,
+          endpoint: /data\/([A-Z].*)\//.match(url)[1]
+        }
+      end
+
+      # Load references and services from disk.
+      def initialize
+        load_references
+        load_services
+      end
+
+      # Load the specified reference file into the container
+      # @param [<Type>] file file to load
+      # @param [<Type>] type type of service the file contains
+      # @return [Void]
+      def load_reference_file(file: nil, type: nil)
+        raise ArgumentError, 'type must be supplied' unless type
+        raise ArgumentError, 'file must be supplied' unless file
+        @raw_reference.store(type, Driver.load_json_file(file))
+        true
+      end
+
+      # Load all available reference files into memory
+      # @return [Void]
+      def load_references
+        @raw_reference = {}
+        Services.types.each do |type|
+          gemdir = if Gem::Specification.find_all.map(&:name).include? 'cts-mpx'
+                     Gem::Specification.find_by_name('cts-mpx').gem_dir
+                   else
+                     # :nocov:
+                     Dir.pwd
+                     # :nocov:
+                   end
+
+          Services.load_reference_file(file: "#{gemdir}/config/#{type}_services.json", type: type.to_s)
+        end
+      end
+
+      # Convert the raw reference into a service and add it to the stack of available serrvices
+      # @return [Void]
+      def load_services
+        @services = []
+        raw_reference.each do |type, services|
+          services.each do |name, data|
+            s = Driver::Service.new
+            s.name = name
+            s.uri_hint = data['uri_hint']
+            s.path = data['path']
+            s.form = data['form']
+            s.schema = data['schema']
+            s.search_schema = data['search_schema']
+            s.read_only = data['read_only'] ? true : false
+            s.endpoints = data['endpoints']
+            s.type = type
+            s.instance_variable_set :@url, data['url'] if data['url']
+            @services.push s
+          end
+        end
+      end
+
+      # Raw copy of the reference files
+      # @return [Hash] key is name, value is the data
+      def raw_reference
+        @raw_reference
+      end
+
+      # Single reference from the raw collection.
+      # @param [String] key service title
+      # @return [Hash] values of the reference
+      def reference(key = nil)
+        return @raw_reference unless key
+        raise 'key must be a string' unless key.is_a? String
+        raise "#{key} is not in the reference library." unless @raw_reference.include? key
+        @raw_reference[key]
+      end
+
+      # list of possible types of services
+      # @return [Symbol[]] List of all types
+      def types
+        %i[web data ingest]
+      end
+    end
+  end
+end

data/lib/cts/mpx/services/data.rb

@@ -0,0 +1,124 @@
+module Cts
+  module Mpx
+    module Services
+      # Collection of procedural methods to interact with the Data services
+      # All of these methods mimic the DSS clients as close as possible
+      # If your operation does not work in the DSS client, it will not work here
+      module Data
+        module_function
+
+        # Addressable method, indexed by data service title
+        # @param [String] key service title to look up the service object
+        # @raise [ArgumentError] if the key is not a service name
+        # @raise [ArgumentError] if the key is not a string
+        # @return [Service[]] if no key, return the entire array of services
+        # @return [Service] a service
+        def [](key = nil)
+          services = Services[].select { |s| s.type == 'data' }
+          return services unless key
+          raise ArgumentError, 'key must be a string' unless key.is_a? String
+          service = services.find { |e| e.name == key }
+          raise ArgumentError, "#{key} must be a service name." unless service
+          service
+        end
+
+        # Procedural method to DELETE data from the data services
+        # @raise (see #get)
+        # @param (see #get)
+        # @return (see #get)
+        def delete(user: nil, account: nil, service: nil, endpoint: nil, sort: nil, extra_path: nil, range: nil, ids: nil, query: {}, headers: {}, count: nil, entries: nil)
+          get(user: user, account: account, service: service, endpoint: endpoint, sort: sort, extra_path: extra_path, range: range, ids: ids, query: query, headers: headers, count: count, entries: entries, method: :delete)
+        end
+
+        # Procedural method to GET data from the data services
+        # @param [Boolean] count ask for a count of objects from the services
+        # @param [Boolean] entries return an array of entries
+        # @param [User] user user to make calls with
+        # @param [Hash] query additional parameters to add to the http call
+        # @param [Hash] headers additional headers to attach to the http call
+        # @param [String] account context account id or name
+        # @param [String] endpoint endpoint to make the call against
+        # @param [String] extra_path additional part to add to the path
+        # @param [String] fields comma delimited list of fields to collect
+        # @param [String] ids comma delimited list of short id's to add to the path
+        # @param [String] range string (service) format of a range
+        # @param [String] service title of a service
+        # @param [String] sort set the sort field
+        # @raise (see #prep_call)
+        # @return [Response] Response of the call
+        def get(user: nil, account: nil, service: nil, fields: nil, endpoint: nil, sort: nil, extra_path: nil, range: nil, ids: nil, query: {}, headers: {}, count: nil, entries: nil, method: :get)
+          prep_call(user: user, account: account, service: service, query: query, headers: headers, required_arguments: ['user', 'service', 'endpoint'], binding: binding)
+
+          host = Driver::Assemblers.host user: user, service: service
+          path = Driver::Assemblers.path service: service, endpoint: endpoint, extra_path: extra_path, ids: ids
+          query = Driver::Assemblers.query user: user, account: account, service: service, endpoint: endpoint, query: query
+
+          if Services[service].type == 'data'
+            query.merge! Driver::Assemblers.query_data range: range, count: count, entries: entries, sort: sort
+            query[:fields] = fields if fields
+          end
+          request = Driver::Request.create(method: method, url: [host, path].join, query: query, headers: headers)
+          request.call
+        end
+
+        # Procedural method to POST data to the data services
+        # @param [Driver::Page] page formated page to send to the data services
+        # @param [User] user user to make calls with
+        # @param [Hash] query additional parameters to add to the http call
+        # @param [Query] headers additional headers to attach to the http call
+        # @param [String] account account context, can be id or name
+        # @param [String] endpoint endpoint to make the call against
+        # @param [String] extra_path additional part to add to the path
+        # @param [String] service title of a service
+        # @raise (see #prep_call)
+        # @return [Response] Response of the call
+        def post(user: nil, account: nil, service: nil, endpoint: nil, extra_path: nil, query: {}, page: nil, headers: {}, method: :post)
+          prep_call(user: user, account: account, service: service, query: query, headers: headers, required_arguments: ['user', 'service', 'endpoint', 'page'], page: page, binding: binding)
+
+          host = Driver::Assemblers.host user: user, service: service
+          path = Driver::Assemblers.path service: service, endpoint: endpoint, extra_path: extra_path
+          query = Driver::Assemblers.query user: user, account: account, service: service, endpoint: endpoint, query: query
+
+          request = Driver::Request.create(method: method, url: [host, path].join, query: query, headers: headers, payload: page.to_s)
+          request.call
+        end
+
+        # Procedural method to PUT data to the data services
+        # @param (see #post)
+        # @raise (see #post)
+        # @return (see #post)
+        def put(user: nil, account: nil, service: nil, endpoint: nil, extra_path: nil, query: {}, page: nil, headers: {})
+          post(user: user, account: account, service: service, endpoint: endpoint, extra_path: extra_path, query: query, page: page, headers: headers, method: :put)
+        end
+
+        # Helper method to assure that everything is is ok to call the methods above
+        # @param [Hash] args params to assure are correct
+        # @option args [Symbol] :account account to apply to account_context lookups
+        # @option args [Symbol] :binding local binding (goes with required arguments)
+        # @option args [Symbol] :headers header object to check
+        # @option args [Symbol] :page page to send to the data service
+        # @option args [Symbol] :query query object to test
+        # @option args [Symbol] :required_arguments list of arguments required
+        # @option args [Symbol] :service title of the service
+        # @option args [Symbol] :user user to make calls with
+        # @raise [ArgumentError] if :query or :headers values are not a Hash
+        # @raise [ArgumentError] if the :page value is not a Page
+        # @raise [ArgumentError] if the list of :required_arguments are not set
+        # @raise [ArgumentError] if the :user does not have a token
+        # @raise (see Registry#fetch_domain)
+        # @raise (see Registry#store_domain)
+        # @return [Response] Response of the call
+        # @private
+        def prep_call(args = {})
+          Driver::Helpers.required_arguments args[:required_arguments], args[:binding]
+          args[:user].token!
+          Driver::Helpers.raise_if_not_a_hash [args[:query], args[:headers]]
+
+          Driver::Helpers.raise_if_not_a([args[:page]], Driver::Page) if args[:page]
+
+          Registry.fetch_and_store_domain(args[:user], args[:account]) unless self[args[:service]].url?
+        end
+      end
+    end
+  end
+end