cts-mpx 1.0.1

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

@@ -0,0 +1,60 @@
+module Cts
+  module Mpx
+    module Services
+      # Collection of methods to interact with the ingest services
+      module Ingest
+        module_function
+
+        # Addressable method, indexed by ingest service title
+        # @param [String] key ingest 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
+          Driver::Exceptions.raise_unless_argument_error?(key, String)
+
+          service = services.find { |e| e.name == key }
+          Driver::Exceptions.raise_unless_argument_error?(service, Driver::Service)
+
+          service
+        end
+
+        # Ingest service list
+        # @return [Services[]] Array of ingest services
+        def services
+          Services[].select { |s| s.type == 'ingest' }
+        end
+
+        # Procedural method to interact with an ingest service via POST
+        # @param [User] user user to make calls with
+        # @param [Hash] 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] payload string to send to ingest
+        # @param [String] service title of a service
+        # @raise [ArgumentError] if headers is not a [Hash]
+        # @raise [ArgumentError] if the list of [User], service or endpoint is not included
+        # @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
+        def post(user: nil, account: nil, service: nil, endpoint: nil, headers: {}, payload: nil, extra_path: nil)
+          Driver::Helpers.required_arguments ['user', 'service', 'endpoint'], binding
+          Driver::Helpers.raise_if_not_a_hash [headers]
+          user.token!
+
+          Registry.fetch_and_store_domain(user, account) unless self[service].url?
+
+          host = Driver::Assemblers.host user: user, service: service
+          path = Driver::Assemblers.path service: service, endpoint: endpoint, extra_path: extra_path
+
+          request = Driver::Request.create(method: :post, url: [host, path].join, payload: payload, headers: headers)
+          request.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Cts
+  module Mpx
+    module Services
+      # Collection of procedural methods to interact with the Web services
+      # All of these methods mimic the Business clients as close as possible
+      # If your operation does not work in the Business client, it will not work here
+      module Web
+        module_function
+
+        # Addressable method, indexed by web 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
+          Driver::Exceptions.raise_unless_argument_error?(key, String)
+
+          service = services.find { |e| e.name == key }
+          Driver::Exceptions.raise_unless_argument_error?(service, Driver::Service)
+
+          service
+        end
+
+        # Web service list
+        # @return [Services[]] Array of web services
+        def services
+          Services[].select { |s| s.type == 'web' }
+        end
+
+        # assembles service, endpoint, method, and arguments into a payload
+        # @param [String] service title of a service
+        # @param [String] endpoint endpoint to make the call against
+        # @param [String] method method to make the call against
+        # @param [Hash] arguments arguments to send to the method
+        # @return [Hash] a hash ready for the web services
+        def assemble_payload(service: nil, endpoint: nil, method: nil, arguments: nil)
+          Driver::Helpers.required_arguments ['service', 'endpoint', 'method', 'arguments'], binding
+          service = Services[service]
+          method_list = service.endpoints[endpoint]['methods']
+          Driver::Exceptions.raise_unless_argument_error?(arguments, Hash)
+          Driver::Exceptions.raise_unless_argument_error?(method, 'method') { method_list.key?(method) }
+
+          arguments.each_key { |k| Driver::Exceptions.raise_unless_argument_error?(arguments, 'argument') { method_list[method].include? k.to_s } }
+
+          h = {}
+          h[method] = arguments
+          h
+        end
+
+        # Procedural method to interact with a web service via POST
+        # @param [User] user user to make calls with
+        # @param [Hash] headers additional headers to attach to the http call
+        # @param [Hash] query additional parameters to add to the http call
+        # @param [Hash] arguments data to be sent to the data service
+        # @param [String] account account context, can be id or name
+        # @param [String] method method to make the call against
+        # @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 [ArgumentError] if headers is not a [Hash]
+        # @raise [ArgumentError] if the list of [User], service or endpoint is not included
+        # @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
+        def post(user: nil, account: nil, service: nil, endpoint: nil, method: nil, query: {}, headers: {}, arguments: {}, extra_path: nil)
+          ### check arguments
+          Driver::Helpers.required_arguments ['user', 'service', 'endpoint', 'method', 'arguments'], binding
+          Driver::Helpers.raise_if_not_a_hash [query, headers, arguments]
+          user.token!
+
+          ### Registry
+          Registry.fetch_and_store_domain(user, account) unless self[service].url?
+
+          ### Assemblers/prep
+          host = Driver::Assemblers.host user: user, service: service
+          path = Driver::Assemblers.path service: service, endpoint: endpoint, extra_path: extra_path
+          payload = assemble_payload service: service, endpoint: endpoint, method: method, arguments: arguments
+          query = Driver::Assemblers.query user: user, account: account, service: service, endpoint: endpoint, query: query
+
+          ### Request
+          request = Driver::Request.create(method: :post, url: [host, path].join, query: query, payload: Oj.dump(payload), headers: headers)
+          request.call
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/user.rb

@@ -0,0 +1,74 @@
+module Cts
+  module Mpx
+    # Class to wrap the user and basic functions related to it.
+    # @attribute username
+    #   @return [String] username of the user
+    # @attribute password
+    #   @return [String] password of the user
+    # @attribute idle_timeout
+    #   @return [Numeric] how long the token will stay alive without communicating with the services
+    # @attribute duration
+    #   @return [Numeric] total time to live for the token
+    # @attribute token
+    #   @return [String] the retrieved token
+    class User
+      extend Creatable
+
+      attribute name: 'username', type: 'accessor', kind_of: String
+      attribute name: 'password', type: 'accessor', kind_of: String
+      attribute name: 'idle_timeout', type: 'accessor', kind_of: Integer
+      attribute name: 'duration', type: 'accessor', kind_of: Integer
+      attribute name: 'token', type: 'accessor', kind_of: String
+
+      # Attempt to sign the user in with the provided credentials
+      # @param [Numeric] idle_timeout how long the token will stay alive without communicating with the services
+      # @param [Numeric] duration total time to live for the token
+      # @return [Self]
+      def sign_in(idle_timeout: nil, duration: nil)
+        raise 'token is already set, use sign_out first.' if token
+        arguments = {}
+
+        arguments['idleTimeout'] if idle_timeout
+        arguments['duration'] if duration
+        headers = { 'Authorization' => "Basic #{Base64.encode64("#{username}:#{password}").tr "\n", ''}" }
+
+        self.token = 'sign_in_token'
+        response = Services::Web.post user: self, service: 'User Data Service', endpoint: 'Authentication', method: 'signIn', arguments: arguments, headers: headers
+
+        raise "sign_in exception, status: #{response.status}" unless response.status == 200
+        self.token = response.data['signInResponse']['token']
+        self
+      end
+
+      # Sign the token out
+      # @return [Void]
+      def sign_out
+        arguments = { "token" => token }
+        response = Services::Web.post user: self, service: 'User Data Service', endpoint: 'Authentication', method: 'signOut', arguments: arguments
+        self.token = nil if response.status == 200
+        nil
+      end
+
+      # Override to masq the password
+      # @return [String] updated output
+      def inspect
+        output = "#<#{self.class}:#{(object_id << 1).to_s(16)}"
+
+        %i[username token idle_timeout duration].each do |attribute|
+          value = instance_variable_get "@#{attribute}".to_sym
+          output += " @#{attribute}=#{value}" unless value.nil?
+        end
+
+        output += '>'
+        output
+      end
+
+      # raise an error if the token is not set, otherwise return the token
+      # @return [String] token
+      def token!
+        raise "#{username} is not signed in, (token is set to nil)." unless token
+        token
+      end
+    end
+  end
+end

data/lib/cts/mpx/validators.rb

@@ -0,0 +1,51 @@
+module Cts
+  module Mpx
+    #
+    # Collection of methods that will validate input based on specific tests.
+    #
+    module Validators
+      module_function
+
+      # Validates if a string is a long form id
+      # @param [String] account_id long form id
+      # @return [Boolean] true if it is a long form id, false if it is not.
+      def account_id?(account_id)
+        return true if account_id == 'urn:theplatform:auth:root'
+        return false unless reference? account_id
+        return false unless account_id.downcase.match?(/\/account\/\d+$/)
+
+        true
+      end
+
+      # Test to check for validity of argument by type, can also accept a block.
+      # @note test
+      # @param [Object] data object to check
+      # @param [Class] type class type to accept
+      # @yield Description of block
+      # @yieldreturn [boolean] true if the outcome is valid, false otherwise.
+      # @return [boolean] true if the outcome is valid, false otherwise.
+      def argument_error?(data, type = nil, &block)
+        return block.yield if block
+        return true unless type && data.is_a?(type)
+        false
+      end
+
+      # Validates if a string is a reference
+      # @param [String] uri reference
+      # @return [Boolean] true if it is a reference, false if it is not.
+      def reference?(uri)
+        begin
+          ref = URI.parse uri
+        rescue URI::InvalidURIError
+          return false
+        end
+
+        return false if ref.host == 'web.theplatform.com'
+        return false unless ref.scheme == "http" || ref.scheme == "https"
+        return false unless ref.host.end_with? ".theplatform.com"
+        return false if ref.host.start_with? 'feed.media.theplatform'
+        true
+      end
+    end
+  end
+end

data/lib/cts/mpx/version.rb

@@ -0,0 +1,6 @@
+module Cts
+  module Mpx
+    # @return [String] frozen string of the version of Cts::Mpx
+    VERSION = "1.0.1".freeze
+  end
+end

data/uml.nomnoml

@@ -0,0 +1,242 @@
+[<module> Assemblers|
+  |
+     host(user: nil, service: nil, account_id: 'urn:theplatform:auth:root')
+     path(service: nil, endpoint: nil, extra_path: nil, ids: nil, account: 'urn:theplatform:auth:root')
+     query(user: nil, account: nil, service: nil, endpoint: nil, query: {}, range: nil, count: nil, entries: nil, sort: nil)
+     query_data(range: nil, count: nil, entries: nil, sort: nil)
+ ]
+ [<module> Connections|
+  |
+     \[\](uri = nil)
+ ]
+ [<module> Helpers|
+  |
+     raise_if_not_a(objects, type)
+     raise_if_not_an_array(objects)
+     raise_if_not_a_hash(objects)
+     required_arguments(arguments, a_binding)
+ ]
+ [<class> Page|
+     +entries kind_of:Array
+       +xmlns kind_of:Hash
+    |
+     initialize
+     to_s(indent_depth = nil)
+ ]
+ [<class> Request|
+     +method kind_of:Symbol
+       +url kind_of:String
+       +query kind_of:Hash
+       +payload kind_of:String
+       +response kind_of:::Cts::Mpx::Driver::Response
+       +headers kind_of:Hash
+    |
+     call
+     call_exceptions(method, url)
+ ]
+ [<class> Response|
+     +original kind_of:Excon::Response
+    |
+     data
+     healthy?
+     service_exception?
+     page
+     status
+ ]
+ [<module> Driver|
+  |
+     gem_dir
+     config_dir
+     load_json_file(filename)
+ ]
+ [<class> Entries|
+     +collection kind_of:Array
+    |
+     self.create_from_page(page)
+     \[\](key = nil)
+     add(entry)
+     each
+     initialize
+     remove(argument)
+     reset
+ ]
+ [<class> Entry|
+     +data kind_of:Hash
+       +endpoint kind_of:String
+       +fields kind_of:Fields
+       +id kind_of:String
+       +service kind_of:String
+       +xmlns kind_of:Hash
+    |
+     self.load_by_id(user: nil, id: nil, fields: nil)
+     id
+     id=(value)
+     initialize
+     load(user: nil, fields: nil)
+     save(user: nil)
+ ]
+ [<module> Exceptions|
+  |
+     raise_unless_account_id(argument)
+ ]
+ [<module> Exceptions|
+  |
+     raise_unless_argument_error?(data, type = nil, &block)
+ ]
+ [<module> Exceptions|
+  |
+     raise_unless_reference?(argument)
+ ]
+ [<module> Exceptions|
+  |
+     raise_unless_required_argument?(argument: nil)
+ ]
+ [<class> Field|
+     +field_name kind_of:String
+       +xmlns kind_of:Hash
+    |
+     name
+     qualified_field_name
+     to_s
+     to_h
+     type
+ ]
+ [<class> Fields|
+     +collection kind_of:Array
+    |
+     self.create_from_data(data: nil, xmlns: nil)
+     \[\](key = nil)
+     \[\]=(key, value, xmlns: nil)
+     add(field)
+     each
+     initialize
+     parse(xmlns: nil, data: nil)
+     remove(field_name)
+     reset
+     to_h
+     to_s
+     xmlns
+ ]
+ [<class> Query|
+     +account kind_of:String
+       +endpoint kind_of:String
+       +extra_path kind_of:String
+       +fields kind_of:String
+       +ids kind_of:Array
+       +page kind_of:Driver::Page
+       +query kind_of:Hash
+       +range kind_of:String
+       +return_count kind_of:FalseClass
+       +return_entries kind_of:TrueClass
+       +service kind_of:String
+       +sort kind_of:String
+    |
+     attributes
+     initialize
+     entries
+     run(user: nil)
+     url(user: nil, token: nil); end
+     params
+ ]
+ [<module> Registry|
+  |
+     domains
+     fetch_and_store_domain(user, account_id = 'urn:theplatform:auth:root')
+     fetch_domain(user, account_id = 'urn:theplatform:auth:root')
+     store_domain(data, account_id = 'urn:theplatform:auth:root')
+     initialize
+     raise_argument_error(data, name)
+ ]
+ [<class> Service|
+  |
+     initialize
+     url(account_id = 'urn:theplatform:auth:root')
+     url?(account_id = 'urn:theplatform:auth:root')
+ ]
+ [<module> Data|
+  |
+     \[\](key = nil)
+     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: 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)
+     post(user: nil, account: nil, service: nil, endpoint: nil, extra_path: nil, query: {}, page: nil, headers: {}, method: :post)
+     put(user: nil, account: nil, service: nil, endpoint: nil, extra_path: nil, query: {}, page: nil, headers: {})
+     prep_call(args = {})
+ ]
+ [<module> Ingest|
+  |
+     \[\](key = nil)
+     services
+     post(user: nil, account: nil, service: nil, endpoint: nil, headers: {}, payload: nil, extra_path: nil)
+ ]
+ [<module> Web|
+  |
+     \[\](key = nil)
+     services
+     assemble_payload(service: nil, endpoint: nil, method: nil, arguments: nil)
+     post(user: nil, account: nil, service: nil, endpoint: nil, method: nil, query: {}, headers: {}, arguments: {}, extra_path: nil)
+ ]
+ [<module> Services|
+  |
+     \[\](key = nil)
+     from_url(url)
+     initialize
+     load_reference_file(file: nil, type: nil)
+     load_references
+     load_services
+     raw_reference
+     reference(key = nil)
+     types
+ ]
+ [<class> User|
+  |
+     sign_in(idle_timeout: nil, duration: nil)
+     sign_out
+     token!
+ ]
+ [<module> Validators|
+  |
+     account_id?(account_id)
+ ]
+ [<module> Validators|
+  |
+     argument_error?(data, type = nil, &block)
+ ]
+ [<module> Validators|
+  |
+     reference?(uri)
+ ]
+ [<module> Validators|
+  |
+     required_argument?(argument: nil)
+ ]
+ [<module> Mpx|
+  |
+ ]
+ [<module> Mpx|
+  |
+ ]
+
+
+[Cts]->[Mpx]
+[Mpx]->[User]
+[Mpx]->[Entries]
+[Mpx]->[Entry]
+[Mpx]->[Field]
+[Mpx]->[Fields]
+[Mpx]->[Query]
+[Mpx]->[Registry]
+[Mpx]->[Service]
+[Mpx]->[Services]
+[Mpx]->[Exceptions]
+[Mpx]->[Driver]
+[Mpx]->[Validators]
+
+[Driver]->[Assemblers]
+[Driver]->[Connections]
+[Driver]->[Helpers]
+[Driver]->[Page]
+[Driver]->[Request]
+[Driver]->[Response]
+[Services]->[Data]
+[Services]->[Web]
+[Services]->[Ingest]