cts-mpx 1.0.1

data/lib/cts/mpx/driver/page.rb

@@ -0,0 +1,38 @@
+module Cts
+  module Mpx
+    module Driver
+      # <Description>
+      # @attribute entries
+      #   @return [Array] array of deserialized entries
+      # @attribute xmlns
+      #   @return [Hash] active namespace received for this page
+      class Page
+        extend Creatable
+        include Enumerable
+
+        attribute name: 'entries', kind_of: Array
+        attribute name: 'xmlns', kind_of: Hash
+
+        def initialize
+          @entries = []
+          @xmlns = {}
+        end
+
+        # return a json copy of the object, useful for later interpreation
+        # @param [Object] indent_depth sets indent depth to 2 if not nil
+        # @return [String] json serialized copy of the page
+        def to_s(indent_depth = nil)
+          indent_depth = 2 if indent_depth
+
+          Oj.dump(
+            {
+              "xmlns"   => xmlns,
+              "entries" => entries
+            },
+            indent: indent_depth
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/driver/request.rb

@@ -0,0 +1,60 @@
+module Cts
+  module Mpx
+    module Driver
+      #
+      # A single request of any type to the services.
+      #
+      # @attribute method
+      #   @return [Symbol] type of rest method, GET, PUT, POST, DELETE
+      # @attribute url
+      #   @return [String] url to make the request against
+      # @attribute query
+      #   @return [Hash] query to send with the request
+      # @attribute payload
+      #   @return [String] payload to be sent to the services
+      # @attribute response
+      #   @return [Cts::Mpx::Driver::Response] response from the service
+      # @attribute headers
+      #   @return [Hash] headers to transmit to the services along with the request
+      class Request
+        extend Creatable
+
+        attribute name: 'method', kind_of: Symbol
+        attribute name: 'url', kind_of: String
+        attribute name: 'query', kind_of: Hash
+        attribute name: 'payload', kind_of: String
+        attribute name: 'response', kind_of: ::Cts::Mpx::Driver::Response
+        attribute name: 'headers', kind_of: Hash
+
+        # Call the built request.
+        # @raise [RuntimeException] if the method is not a get, put, post or delete
+        # @raise [RuntimeException] if the url is not a valid reference
+        # @return [Cts::Mpx::Driver::Response] response from the service
+        def call
+          @headers ||= {}
+          @query ||= {}
+
+          call_exceptions method, url
+          socket = Connections[url]
+          params = {
+            headers: @headers,
+            path:    URI.parse(url).path,
+            query:   @query
+          }
+          params[:body] = payload if payload
+
+          r = socket.send method, params
+          @response = Response.create original: r
+          @response
+        end
+
+        private
+
+        def call_exceptions(method, url)
+          raise "#{method} is not a valid method" unless %i[get put post delete].include? method.downcase
+          raise "#{url} is not a valid reference" unless Cts::Mpx::Validators.reference? url
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/driver/response.rb

@@ -0,0 +1,72 @@
+module Cts
+  module Mpx
+    module Driver
+      #
+      # Class to contain a response from the services, has a few helper methods to make reading the data easier.
+      #
+      class Response
+        extend Creatable
+
+        # @!attribute original
+        #   @return [Excon::Response] copy of the original excon response.
+        attribute name: 'original', kind_of: Excon::Response
+
+        #
+        # Hash output of the data returned from the services.
+        #
+        # @return [Hash] Hash including keys specific to the service and type of service.
+        #
+        def data
+          return @data if @data
+
+          raise 'response does not appear to be healthy' unless healthy?
+
+          begin
+            @data = Oj.load(original.body)
+          rescue Oj::ParseError => e
+            raise "could not parse data: #{e}"
+          end
+          @data
+        end
+
+        #
+        # Is the response healthy?   did it have a status code outside 2xx or 3xx.
+        #
+        # @return [TrueFalse] false if status <= 199 or => 400, otherwise true.
+        #
+        def healthy?
+          return false if status <= 199 || status >= 400
+          true
+        end
+
+        #
+        # Does this response contain a service exception
+        #
+        # @return [TrueFalse] true if it does, false if it does not.
+        #
+        def service_exception?
+          data['isException'] == true
+        end
+
+        #
+        # a page of data, processes the response.data for any entries.
+        #
+        # @return [Cts::Mpx::Driver::Page] a page of data.
+        #
+        def page
+          raise 'response does not appear to be healthy' unless healthy?
+          Cts::Mpx::Driver::Page.create entries: data['entries'], xmlns: data['$xmlns']
+        end
+
+        #
+        # Status code of the response
+        #
+        # @return [Fixnum] http status code
+        #
+        def status
+          original.status || nil
+        end
+      end
+    end
+  end
+end

data/lib/cts/mpx/entries.rb

@@ -0,0 +1,80 @@
+module Cts
+  module Mpx
+    # Enumerable collection that can store an entry in it
+    # @attribute collection storage for the individual entry
+    #   @return [Entry[]]
+    class Entries
+      include Enumerable
+      include Driver
+      extend Creatable
+
+      attribute name: 'collection', kind_of: Array
+
+      # Create a new entries collection from a page
+      # @param [Page] page the page object to process
+      # @raise [ArgumentError] if :page is not available
+      # @return [Entries] a new entries collection
+      def self.create_from_page(page)
+        Exceptions.raise_unless_argument_error? page, Page
+        entries = new
+        page.entries.each do |e|
+          entry = Entry.new
+          entry.fields = Fields.create_from_data(data: e, xmlns: page.xmlns)
+          entry.id = entry.fields['id'] if entry.fields['id']
+          entries.add entry
+        end
+        entries
+      end
+
+      # Addressable method, indexed by entry object
+      # @param [Entry] key the entry to return
+      # @return [Self.collection,Entry,nil] Can return the collection, a single entry, or nil if nothing found
+      def [](key = nil)
+        return @collection unless key
+        @collection.find { |e| e.id == key }
+      end
+
+      # Add an entry object to the collection
+      # @param [Entry] entry instantiated Entry to include
+      # @raise [ArgumentError] if entry is not an Entry
+      # @return [Self]
+      def add(entry)
+        return self if @collection.include? entry
+        Exceptions.raise_unless_argument_error? entry, Entry
+        @collection.push entry
+        self
+      end
+
+      # Iterator method for self
+      # @return [Entry] next object in the list
+      def each
+        @collection.each { |c| yield c }
+      end
+
+      # Reset the entry array to a blank state
+      # @return [Void]
+      def initialize
+        reset
+      end
+
+      # Remove a entry object from the collection
+      # @param [Entry] argument instantiated Entry to remove
+      # @return [Self]
+      def remove(argument)
+        @collection.delete_if { |f| f == argument }
+      end
+
+      # Reset the entry array to a blank state
+      # @return [Void]
+      def reset
+        @collection = []
+      end
+
+      # A hash of all available entries
+      # @return [Hash]
+      def to_h
+        map(&:to_h)
+      end
+    end
+  end
+end

data/lib/cts/mpx/entry.rb

@@ -0,0 +1,100 @@
+module Cts
+  module Mpx
+    # ORM style class to contain any entry from the data services.
+    class Entry
+      extend Creatable
+
+      attribute name: 'endpoint', kind_of: String
+      attribute name: 'fields', kind_of: Fields
+      attribute name: 'id', kind_of: String
+      attribute name: 'service', kind_of: String
+
+      # Load a Entry based on a long form ID
+      # @param [User] user user to make calls with
+      # @param [String] id long form id to look up
+      # @param [String] fields comma delimited list of fields to collect
+      # @return [Entry] the resulting entry
+      def self.load_by_id(user: nil, id: nil, fields: nil)
+        Driver::Helpers.required_arguments %i[user id], binding
+
+        Driver::Exceptions.raise_unless_argument_error? user, User
+        Driver::Exceptions.raise_unless_reference? id
+
+        e = new
+        e.id = id
+        e.load user: user, fields: nil
+        e
+      end
+
+      # Return the id of the entry.
+      # @return [Entry] the resulting entry
+      def id
+        fields['id']
+      end
+
+      # Set the id of the entry, will check if it's a valid reference.
+      # @param [String] account_id account_id to set the entry to
+      # @return [Entry] the resulting entry
+      def id=(account_id)
+        Driver::Exceptions.raise_unless_reference? account_id
+        result = Services.from_url account_id
+        fields['id'] = account_id
+
+        @service = result[:service]
+        @endpoint = result[:endpoint]
+      end
+
+      # Initialize an entry.
+      # Currently only instantiates fields.
+      def initialize
+        @fields = Fields.new
+      end
+
+      # Return a [Hash] of the entry.
+      # @return [Hash] includes keys xmlns: [Hash] and entries: [Fields]
+      def to_h
+        {
+          xmlns: fields.xmlns,
+          entry: fields.to_h
+        }
+      end
+
+      # Load data from the remote services based on the id.
+      # @param [User] user user to make calls with
+      # @param [String] fields comma delimited list of fields to collect
+      # @return [Driver::Response] Response of the call.
+      def load(user: nil, fields: nil)
+        Driver::Helpers.required_arguments %i[user], binding
+
+        Driver::Exceptions.raise_unless_argument_error? user, User
+        Driver::Exceptions.raise_unless_argument_error? fields, String if fields
+        Driver::Exceptions.raise_unless_reference? id
+
+        response = Services::Data.get user: user, service: service, endpoint: endpoint, fields: fields, ids: id.split("/").last
+        self.fields.parse data: response.data['entries'].first, xmlns: response.data['xmlns']
+        response
+      end
+
+      # Save the entry to the remote services.
+      # @param [User] user user to make calls with
+      # @return [Driver::Response] Response of the call.
+      def save(user: nil)
+        Driver::Helpers.required_arguments %i[user], binding
+        Driver::Exceptions.raise_unless_argument_error? user, User
+
+        p = Driver::Page.create entries: [fields.to_h], xmlns: fields.xmlns
+
+        if id
+          response = Services::Data.put user: user, service: service, endpoint: endpoint, page: p
+        else
+          raise ArgumentError, "service is a required keyword" unless service
+          raise ArgumentError, "endpoint is a required keyword" unless endpoint
+
+          response = Services::Data.post user: user, service: service, endpoint: endpoint, page: p
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/cts/mpx/field.rb

@@ -0,0 +1,38 @@
+module Cts
+  module Mpx
+    # Indivudal field, contains the name, value, and an optional namespace
+    # @attribute name name of the field
+    #   @return [String]
+    # @attribute value value of the field
+    #   @return [Object]
+    # @attribute xmlns namespace of the field
+    #   @return [Hash]
+    class Field
+      extend Creatable
+
+      attribute name: 'name', kind_of: String
+      attribute name: 'value'
+      attribute name: 'xmlns', kind_of: Hash
+
+      # Return just the name value as key/value
+      # @return [Hash]
+      def to_h
+        { name => value }
+      end
+
+      # Determines if this field is a custom field or not
+      # @return [Symbol] :internal or :custom if it is a custom field
+      def type
+        return :custom if name.include? "$"
+        :internal
+      end
+
+      # Set the namespace of the field
+      # @param [Hash] xmlns namespace of the fields
+      # @return [Void]
+      def xmlns=(xmlns)
+        @xmlns = xmlns if name.include? '$'
+      end
+    end
+  end
+end

data/lib/cts/mpx/fields.rb

@@ -0,0 +1,120 @@
+module Cts
+  module Mpx
+    # Enumerable collection that can store an entry field in it
+    # @attribute collection storage for the individual field
+    #   @return [Field[]]
+    class Fields
+      include Enumerable
+      extend Creatable
+
+      attribute name: 'collection', kind_of: Array
+
+      # Create a new fields collection from a data hash
+      # @param [Hash] data raw fields to add
+      # @param [Hash] xmlns namespace of the fields
+      # @raise [ArgumentError] if :data or :xmlns are not provided
+      # @return [Fields] a new fields collection
+      def self.create_from_data(data: nil, xmlns: nil)
+        Driver::Helpers.required_arguments([:data], binding)
+        obj = new
+        obj.parse(data: data, xmlns: xmlns)
+        obj
+      end
+
+      # Addressable method, indexed by field name
+      # @param [String] key name of the field
+      # @return [Self.collection,Field,nil] Can return the collection, a single field, or nil if nothing found
+      def [](key = nil)
+        return @collection unless key
+        result = @collection.find { |f| f.name == key }
+        return result.value if result
+        nil
+      end
+
+      # Addresable set method, indexed by field name
+      # @note will create a new copy if it is not found in the collection
+      # @param [String] key name of the field
+      # @param [Object] value value of the field
+      # @param [Hash] xmlns namespace of the field
+      # @example to include xmlns, you need to use the long format of this method
+      #    fields.[]= 'id', 'value', xmlns: {}
+      # @return [Void]
+      def []=(key, value, xmlns: nil)
+        existing_field = find { |f| f.name == key }
+        if existing_field
+          existing_field.value = value
+        else
+          add Field.create name: key, value: value, xmlns: xmlns
+        end
+      end
+
+      # Add a field object to the collection
+      # @param [Field] field instantiated Field to include
+      # @raise [ArgumentError] if field is not a Field
+      # @return [Self]
+      def add(field)
+        return self if @collection.include? field
+        Driver::Exceptions.raise_unless_argument_error? field, Field
+        @collection.push field
+        self
+      end
+
+      # Iterator method for self
+      # @return [Field] next object in the list
+      def each
+        @collection.each { |c| yield c }
+      end
+
+      # Reset the field array to a blank state
+      # @return [Void]
+      def initialize
+        reset
+      end
+
+      # Parse two hashes into a field array
+      # @note this will also set the collection
+      # @param [Hash] xmlns namespace
+      # @param [Hash] data fields in hash form
+      # @raise [ArgumentError] if xmlns is not a Hash
+      # @return [Field[]] returns a collection of fields
+      def parse(xmlns: nil, data: nil)
+        Driver::Exceptions.raise_unless_argument_error? data, Hash
+        data.delete :service
+        data.delete :endpoint
+        reset
+        @collection = data.map { |k, v| Field.create name: k.to_s, value: v, xmlns: xmlns }
+      end
+
+      # Remove a field object from the collection
+      # @param [String] name instantiated Field to remove
+      # @return [Self]
+      def remove(name)
+        @collection.delete_if { |f| f.name == name }
+      end
+
+      # Reset the field array to a blank state
+      # @return [Void]
+      def reset
+        @collection = []
+      end
+
+      # return the fields as a hash
+      # @return [Hash] key is name, value is value
+      def to_h
+        h = {}
+        each { |f| h.store f.name, f.value }
+        h
+      end
+
+      # Return the cumulative namespace of all Field's in the collection
+      # @return [Hash] key is the namespace key, value is the value
+      def xmlns
+        a = collection.map(&:xmlns).uniq
+        a.delete nil
+        h = {}
+        a.each { |e| h.merge! e }
+        h
+      end
+    end
+  end
+end